src/Systeminfo/JSDeviceCapabilitiesInfo.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
  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 #include <fstream>
  19 #include <pcrecpp.h>
  20 #include <memory>
  21 #include <dlfcn.h>
  22 #include <unistd.h>
  23 #include <JSWebAPIErrorFactory.h>
  24 #include <SecurityExceptions.h>
  25 #include <sensors.h>
  26 #include <system_info.h>
  27 #include <pkgmgr-info.h>
  28 #include "JSDeviceCapabilitiesInfo.h"
  29 #include "plugin_config.h"
  30 #include <Logger.h>
  31
  32 namespace DeviceAPI {
  33 namespace Systeminfo {
  34 using namespace WrtDeviceApis::CommonsJavaScript;
  35 using namespace WrtDeviceApis::Commons;
  36 using namespace DeviceAPI::Common;
  37
  38 namespace {
  39 const char* DEVICE_CAPABILITIES_BLUETOOTH = "bluetooth";
  40 const char* DEVICE_CAPABILITIES_NFC = "nfc";
  41 const char* DEVICE_CAPABILITIES_NFC_RESERVED_PUSH = "nfcReservedPush";
  42 const char* DEVICE_CAPABILITIES_MULTITOUCHCOUNT = "multiTouchCount";
  43 const char* DEVICE_CAPABILITIES_INPUTKEYBOARD = "inputKeyboard";
  44 const char* DEVICE_CAPABILITIES_INPUTKEYBOARD_LAYOUT = "inputKeyboardLayout";
  45 const char* DEVICE_CAPABILITIES_WIFI = "wifi";
  46 const char* DEVICE_CAPABILITIES_WIFIDIRECT = "wifiDirect";
  47 const char* DEVICE_CAPABILITIES_OPENGLES = "opengles";
  48 const char* DEVICE_CAPABILITIES_OPENGLES_TEXTURE_FORMAT = "openglestextureFormat";
  49 const char* DEVICE_CAPABILITIES_OPENGLESVERSION1_1 = "openglesVersion1_1";
  50 const char* DEVICE_CAPABILITIES_OPENGLESVERSION2_0 = "openglesVersion2_0";
  51 const char* DEVICE_CAPABILITIES_FMRADIO = "fmRadio";
  52 const char* DEVICE_CAPABILITIES_PLATFORMVERSION = "platformVersion";
  53 const char* DEVICE_CAPABILITIES_PLATFORMNAME = "platformName";
  54 const char* DEVICE_CAPABILITIES_WEBAPIVERSION = "webApiVersion";
  55 const char* DEVICE_CAPABILITIES_NATIVEAPIVERSION = "nativeApiVersion";
  56 const char* DEVICE_CAPABILITIES_CAMERA = "camera";
  57 const char* DEVICE_CAPABILITIES_CAMERAFRONT = "cameraFront";
  58 const char* DEVICE_CAPABILITIES_CAMERAFRONTFLASH = "cameraFrontFlash";
  59 const char* DEVICE_CAPABILITIES_CAMERABACK = "cameraBack";
  60 const char* DEVICE_CAPABILITIES_CAMERABACKFLASH = "cameraBackFlash";
  61 const char* DEVICE_CAPABILITIES_LOCATION = "location";
  62 const char* DEVICE_CAPABILITIES_LOCATIONGPS = "locationGps";
  63 const char* DEVICE_CAPABILITIES_LOCATIONWPS = "locationWps";
  64 const char* DEVICE_CAPABILITIES_MICROPHONE = "microphone";
  65 const char* DEVICE_CAPABILITIES_USBHOST = "usbHost";
  66 const char* DEVICE_CAPABILITIES_USBACCESSORY = "usbAccessory";
  67 const char* DEVICE_CAPABILITIES_SCREENOUTPUTRCA = "screenOutputRca";
  68 const char* DEVICE_CAPABILITIES_SCREENOUTPUTHDMI = "screenOutputHdmi";
  69 const char* DEVICE_CAPABILITIES_PLATFORMCORECPUARCH = "platformCoreCpuArch";
  70 const char* DEVICE_CAPABILITIES_PLATFORMCOREFPUARCH = "platformCoreFpuArch";
  71 const char* DEVICE_CAPABILITIES_SIPVOIP = "sipVoip";
  72 const char* DEVICE_CAPABILITIES_DUID = "duid";
  73 const char* DEVICE_CAPABILITIES_SPEECH_ROCOGNITION = "speechRecognition";
  74 const char* DEVICE_CAPABILITIES_SPEECH_SYNTHESIS = "speechSynthesis";
  75 const char* DEVICE_CAPABILITIES_ACCELEROMETER = "accelerometer";
  76 const char* DEVICE_CAPABILITIES_ACCELEROMETER_WAKEUP = "accelerometerWakeup";
  77 const char* DEVICE_CAPABILITIES_BAROMETER = "barometer";
  78 const char* DEVICE_CAPABILITIES_BAROMETER_WAKEUP = "barometerWakeup";
  79 const char* DEVICE_CAPABILITIES_GYROSCOPE = "gyroscope";
  80 const char* DEVICE_CAPABILITIES_GYROSCOPE_WAKEUP = "gyroscopeWakeup";
  81 const char* DEVICE_CAPABILITIES_MAGNETOMETER = "magnetometer";
  82 const char* DEVICE_CAPABILITIES_MAGNETOMETER_WAKEUP = "magnetometerWakeup";
  83 const char* DEVICE_CAPABILITIES_PHOTOMETER = "photometer";
  84 const char* DEVICE_CAPABILITIES_PHOTOMETER_WAKEUP = "photometerWakeup";
  85 const char* DEVICE_CAPABILITIES_PROXIMITY = "proximity";
  86 const char* DEVICE_CAPABILITIES_PROXIMITY_WAKEUP = "proximityWakeup";
  87 const char* DEVICE_CAPABILITIES_TILTMETER = "tiltmeter";
  88 const char* DEVICE_CAPABILITIES_TILTMETER_WAKEUP = "tiltmeterWakeup";
  89 const char* DEVICE_CAPABILITIES_DATA_ENCRYPTION = "dataEncryption";
  90 const char* DEVICE_CAPABILITIES_GRAPHICS_ACCELERATION = "graphicsAcceleration";
  91 const char* DEVICE_CAPABILITIES_PUSH = "push";
  92 const char* DEVICE_CAPABILITIES_TELEPHONY = "telephony";
  93 const char* DEVICE_CAPABILITIES_TELEPHONY_MMS = "telephonyMms";
  94 const char* DEVICE_CAPABILITIES_TELEPHONY_SMS = "telephonySms";
  95 const char* DEVICE_CAPABILITIES_SCREENSIZE_NORMAL = "screenSizeNormal";
  96 const char* DEVICE_CAPABILITIES_SCREENSIZE_480_800 = "screenSize480_800";
  97 const char* DEVICE_CAPABILITIES_SCREENSIZE_720_1280 = "screenSize720_1280";
  98 const char* DEVICE_CAPABILITIES_AUTO_ROTATION = "autoRotation";
  99 const char* DEVICE_CAPABILITIES_SHELL_APP_WIDGET = "shellAppWidget";
 100 const char* DEVICE_CAPABILITIES_VISION_IMAGE_RECOGNITION = "visionImageRecognition";
 101 const char* DEVICE_CAPABILITIES_VISION_QRCODE_GENERATION = "visionQrcodeGeneration";
 102 const char* DEVICE_CAPABILITIES_VISION_QRCODE_RECOGNITION = "visionQrcodeRecognition";
 103 const char* DEVICE_CAPABILITIES_VISION_FACE_RECOGNITION = "visionFaceRecognition";
 104 const char* DEVICE_CAPABILITIES_SECURE_ELEMENT = "secureElement";
 105 const char* DEVICE_CAPABILITIES_NATIVE_OSP_COMPATIBLE = "nativeOspCompatible";
 106 }
 107
 108 JSClassRef JSDeviceCapabilitiesInfo::m_classRef = NULL;
 109
 110 JSClassDefinition JSDeviceCapabilitiesInfo::m_classInfo = {
 111     0,
 112     kJSClassAttributeNone,
 113     "devicecapabilitiesinfo",
 114     0,
 115     m_properties,
 116     NULL,
 117     Initialize,
 118     Finalize,
 119     hasProperty,
 120     getProperty,
 121     NULL,
 122     NULL,
 123     NULL,
 124     NULL,
 125     NULL,
 126     NULL,
 127     NULL
 128 };
 129
 130 JSStaticValue JSDeviceCapabilitiesInfo::m_properties[] = {
 131     { DEVICE_CAPABILITIES_BLUETOOTH, getProperty, NULL, kJSPropertyAttributeReadOnly },
 132     { DEVICE_CAPABILITIES_NFC, getProperty, NULL, kJSPropertyAttributeReadOnly },
 133     { DEVICE_CAPABILITIES_NFC_RESERVED_PUSH, getProperty, NULL, kJSPropertyAttributeReadOnly },
 134     { DEVICE_CAPABILITIES_MULTITOUCHCOUNT, getProperty, NULL, kJSPropertyAttributeReadOnly },
 135     { DEVICE_CAPABILITIES_INPUTKEYBOARD, getProperty, NULL, kJSPropertyAttributeReadOnly },
 136     { DEVICE_CAPABILITIES_INPUTKEYBOARD_LAYOUT, getProperty, NULL, kJSPropertyAttributeReadOnly },
 137     { DEVICE_CAPABILITIES_WIFI, getProperty, NULL, kJSPropertyAttributeReadOnly },
 138     { DEVICE_CAPABILITIES_WIFIDIRECT, getProperty, NULL, kJSPropertyAttributeReadOnly },
 139     { DEVICE_CAPABILITIES_OPENGLES, getProperty, NULL, kJSPropertyAttributeReadOnly },
 140     { DEVICE_CAPABILITIES_OPENGLES_TEXTURE_FORMAT, getProperty, NULL, kJSPropertyAttributeReadOnly },
 141     { DEVICE_CAPABILITIES_OPENGLESVERSION1_1, getProperty, NULL, kJSPropertyAttributeReadOnly },
 142     { DEVICE_CAPABILITIES_OPENGLESVERSION2_0, getProperty, NULL, kJSPropertyAttributeReadOnly },
 143     { DEVICE_CAPABILITIES_FMRADIO, getProperty, NULL, kJSPropertyAttributeReadOnly },
 144     { DEVICE_CAPABILITIES_PLATFORMVERSION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 145     { DEVICE_CAPABILITIES_PLATFORMNAME, getProperty, NULL, kJSPropertyAttributeReadOnly },
 146     { DEVICE_CAPABILITIES_WEBAPIVERSION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 147     { DEVICE_CAPABILITIES_NATIVEAPIVERSION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 148     { DEVICE_CAPABILITIES_CAMERA, getProperty, NULL, kJSPropertyAttributeReadOnly },
 149     { DEVICE_CAPABILITIES_CAMERAFRONT, getProperty, NULL, kJSPropertyAttributeReadOnly },
 150     { DEVICE_CAPABILITIES_CAMERAFRONTFLASH, getProperty, NULL, kJSPropertyAttributeReadOnly },
 151     { DEVICE_CAPABILITIES_CAMERABACK, getProperty, NULL, kJSPropertyAttributeReadOnly },
 152     { DEVICE_CAPABILITIES_CAMERABACKFLASH, getProperty, NULL, kJSPropertyAttributeReadOnly },
 153     { DEVICE_CAPABILITIES_LOCATION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 154     { DEVICE_CAPABILITIES_LOCATIONGPS, getProperty, NULL, kJSPropertyAttributeReadOnly },
 155     { DEVICE_CAPABILITIES_LOCATIONWPS, getProperty, NULL, kJSPropertyAttributeReadOnly },
 156     { DEVICE_CAPABILITIES_MICROPHONE, getProperty, NULL, kJSPropertyAttributeReadOnly },
 157     { DEVICE_CAPABILITIES_USBHOST, getProperty, NULL, kJSPropertyAttributeReadOnly },
 158     { DEVICE_CAPABILITIES_USBACCESSORY, getProperty, NULL, kJSPropertyAttributeReadOnly },
 159     { DEVICE_CAPABILITIES_SCREENOUTPUTRCA, getProperty, NULL, kJSPropertyAttributeReadOnly },
 160     { DEVICE_CAPABILITIES_SCREENOUTPUTHDMI, getProperty, NULL, kJSPropertyAttributeReadOnly },
 161     { DEVICE_CAPABILITIES_PLATFORMCORECPUARCH, getProperty, NULL, kJSPropertyAttributeReadOnly },
 162     { DEVICE_CAPABILITIES_PLATFORMCOREFPUARCH, getProperty, NULL, kJSPropertyAttributeReadOnly },
 163     { DEVICE_CAPABILITIES_SIPVOIP, getProperty, NULL, kJSPropertyAttributeReadOnly },
 164     { DEVICE_CAPABILITIES_DUID, getProperty, NULL, kJSPropertyAttributeReadOnly },
 165     { DEVICE_CAPABILITIES_SPEECH_ROCOGNITION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 166     { DEVICE_CAPABILITIES_SPEECH_SYNTHESIS, getProperty, NULL, kJSPropertyAttributeReadOnly },
 167     { DEVICE_CAPABILITIES_ACCELEROMETER, getProperty, NULL, kJSPropertyAttributeReadOnly },
 168     { DEVICE_CAPABILITIES_ACCELEROMETER_WAKEUP, getProperty, NULL, kJSPropertyAttributeReadOnly },
 169     { DEVICE_CAPABILITIES_BAROMETER, getProperty, NULL, kJSPropertyAttributeReadOnly },
 170     { DEVICE_CAPABILITIES_BAROMETER_WAKEUP, getProperty, NULL, kJSPropertyAttributeReadOnly },
 171     { DEVICE_CAPABILITIES_GYROSCOPE, getProperty, NULL, kJSPropertyAttributeReadOnly },
 172     { DEVICE_CAPABILITIES_GYROSCOPE_WAKEUP, getProperty, NULL, kJSPropertyAttributeReadOnly },
 173     { DEVICE_CAPABILITIES_MAGNETOMETER, getProperty, NULL, kJSPropertyAttributeReadOnly },
 174     { DEVICE_CAPABILITIES_MAGNETOMETER_WAKEUP, getProperty, NULL, kJSPropertyAttributeReadOnly },
 175     { DEVICE_CAPABILITIES_PHOTOMETER, getProperty, NULL, kJSPropertyAttributeReadOnly },
 176     { DEVICE_CAPABILITIES_PHOTOMETER_WAKEUP, getProperty, NULL, kJSPropertyAttributeReadOnly },
 177     { DEVICE_CAPABILITIES_PROXIMITY, getProperty, NULL, kJSPropertyAttributeReadOnly },
 178     { DEVICE_CAPABILITIES_PROXIMITY_WAKEUP, getProperty, NULL, kJSPropertyAttributeReadOnly },
 179     { DEVICE_CAPABILITIES_TILTMETER, getProperty, NULL, kJSPropertyAttributeReadOnly },
 180     { DEVICE_CAPABILITIES_TILTMETER_WAKEUP, getProperty, NULL, kJSPropertyAttributeReadOnly },
 181     { DEVICE_CAPABILITIES_DATA_ENCRYPTION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 182     { DEVICE_CAPABILITIES_GRAPHICS_ACCELERATION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 183     { DEVICE_CAPABILITIES_PUSH, getProperty, NULL, kJSPropertyAttributeReadOnly },
 184     { DEVICE_CAPABILITIES_TELEPHONY, getProperty, NULL, kJSPropertyAttributeReadOnly },
 185     { DEVICE_CAPABILITIES_TELEPHONY_MMS, getProperty, NULL, kJSPropertyAttributeReadOnly },
 186     { DEVICE_CAPABILITIES_TELEPHONY_SMS, getProperty, NULL, kJSPropertyAttributeReadOnly },
 187     { DEVICE_CAPABILITIES_SCREENSIZE_NORMAL, getProperty, NULL, kJSPropertyAttributeReadOnly },
 188     { DEVICE_CAPABILITIES_SCREENSIZE_480_800, getProperty, NULL, kJSPropertyAttributeReadOnly },
 189     { DEVICE_CAPABILITIES_SCREENSIZE_720_1280, getProperty, NULL, kJSPropertyAttributeReadOnly },
 190     { DEVICE_CAPABILITIES_AUTO_ROTATION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 191     { DEVICE_CAPABILITIES_SHELL_APP_WIDGET, getProperty, NULL, kJSPropertyAttributeReadOnly },
 192     { DEVICE_CAPABILITIES_VISION_IMAGE_RECOGNITION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 193     { DEVICE_CAPABILITIES_VISION_QRCODE_GENERATION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 194     { DEVICE_CAPABILITIES_VISION_QRCODE_RECOGNITION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 195     { DEVICE_CAPABILITIES_VISION_FACE_RECOGNITION, getProperty, NULL, kJSPropertyAttributeReadOnly },
 196     { DEVICE_CAPABILITIES_SECURE_ELEMENT, getProperty, NULL, kJSPropertyAttributeReadOnly },
 197     { DEVICE_CAPABILITIES_NATIVE_OSP_COMPATIBLE, getProperty, NULL, kJSPropertyAttributeReadOnly },
 198     { 0, 0, 0, 0 }
 199 };
 200
 201 const JSClassRef JSDeviceCapabilitiesInfo::getClassRef()
 202 {
 203     if (!m_classRef) {
 204         m_classRef = JSClassCreate(&m_classInfo);
 205     }
 206     return m_classRef;
 207 }
 208
 209 const JSClassDefinition* JSDeviceCapabilitiesInfo::getClassInfo()
 210 {
 211     return &m_classInfo;
 212 }
 213
 214 void JSDeviceCapabilitiesInfo::Initialize(JSContextRef context, JSObjectRef object)
 215 {
 216 }
 217
 218 void JSDeviceCapabilitiesInfo::Finalize(JSObjectRef object)
 219 {
 220     LoggerD("Entered");
 221     JSDeviceCapabilitiesPriv* priv = static_cast<JSDeviceCapabilitiesPriv*>(JSObjectGetPrivate(object));
 222     JSObjectSetPrivate(object, NULL);
 223     LoggerD("Deleting DeviceCapabilitiesInfo object");
 224     delete priv;
 225 }
 226
 227 bool JSDeviceCapabilitiesInfo::hasProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName)
 228 {
 229     return JSUtils::hasProperty(m_properties, propertyName);
 230 }
 231
 232 JSObjectRef JSDeviceCapabilitiesInfo::createJSObject(JSContextRef context, const DeviceCapabilitiesPropertiesPtr deviceCapabilitiesInfo)
 233 {
 234     LoggerD("Enter");
 235     JSDeviceCapabilitiesPriv *priv = new JSDeviceCapabilitiesPriv(context, deviceCapabilitiesInfo);
 236     return JSObjectMake(context, getClassRef(), priv);
 237 }
 238
 239 JSValueRef JSDeviceCapabilitiesInfo::getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
 240 {
 241     LoggerD("Enter");
 242     JSDeviceCapabilitiesPriv *priv = static_cast<JSDeviceCapabilitiesPriv*>(JSObjectGetPrivate(object));
 243     if (NULL == priv) {
 244         LoggerE("Private object not set.");
 245         return JSValueMakeUndefined(context);
 246     }
 247
 248     Try
 249     {
 250         DeviceCapabilitiesPropertiesPtr deviceCapabilitiesInfo = priv->getObject();
 251         Converter convert(context);
 252
 253         if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_BLUETOOTH)) {
 254             bool bluetooth = false;
 255             if (system_info_get_value_bool(SYSTEM_INFO_KEY_BLUETOOTH_SUPPORTED, &bluetooth) == SYSTEM_INFO_ERROR_NONE) {
 256                 LoggerD("bluetooth : " << bluetooth);
 257                 deviceCapabilitiesInfo->bluetooth = bluetooth;
 258             }
 259             return convert.toJSValueRef(deviceCapabilitiesInfo->bluetooth);
 260         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_NFC)) {
 261             bool nfc = false;
 262             if (system_info_get_value_bool(SYSTEM_INFO_KEY_NFC_SUPPORTED, &nfc) == SYSTEM_INFO_ERROR_NONE) {
 263                 LoggerD("nfc : " << nfc);
 264                 deviceCapabilitiesInfo->nfc = nfc;
 265             }
 266             return convert.toJSValueRef(deviceCapabilitiesInfo->nfc);
 267         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_NFC_RESERVED_PUSH)) {
 268             bool nfcReservedPush = false;
 269             if (system_info_get_value_bool(SYSTEM_INFO_KEY_NFC_RESERVED_PUSH_SUPPORTED, &nfcReservedPush) == SYSTEM_INFO_ERROR_NONE) {
 270                 LoggerD("nfcReservedPush : " << nfcReservedPush);
 271                 deviceCapabilitiesInfo->nfcReservedPush = nfcReservedPush;
 272             }
 273             return convert.toJSValueRef(deviceCapabilitiesInfo->nfcReservedPush);
 274         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_MULTITOUCHCOUNT)) {
 275             int multiTouchCount = 0;
 276             if (system_info_get_value_int(SYSTEM_INFO_KEY_MULTI_POINT_TOUCH_COUNT, &multiTouchCount) == SYSTEM_INFO_ERROR_NONE) {
 277                 LoggerD("multiTouchCount : " << multiTouchCount);
 278                 deviceCapabilitiesInfo->multiTouchCount = multiTouchCount;
 279             }
 280             return convert.toJSValueRef(deviceCapabilitiesInfo->multiTouchCount);
 281         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_INPUTKEYBOARD)) {
 282             char* inputKeyboard = NULL;
 283             if (system_info_get_value_string(SYSTEM_INFO_KEY_KEYBOARD_TYPE, &inputKeyboard) == SYSTEM_INFO_ERROR_NONE) {
 284                 if (inputKeyboard != NULL) {
 285                     LoggerD("inputKeyboard : " << inputKeyboard);
 286                     if (strcmp(inputKeyboard, "NULL") == 0) {
 287                         deviceCapabilitiesInfo->inputKeyboard = false;
 288                     } else {
 289                         deviceCapabilitiesInfo->inputKeyboard = true;
 290                     }
 291                     free(inputKeyboard);
 292                 }
 293             }
 294             return convert.toJSValueRef(deviceCapabilitiesInfo->inputKeyboard);
 295         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_INPUTKEYBOARD_LAYOUT)) {
 296             char* inputKeyboard = NULL;
 297             if (system_info_get_value_string(SYSTEM_INFO_KEY_KEYBOARD_TYPE, &inputKeyboard) == SYSTEM_INFO_ERROR_NONE) {
 298                 if (inputKeyboard != NULL) {
 299                     LoggerD("inputKeyboard : " << inputKeyboard);
 300                     if (strcmp(inputKeyboard, "NULL") == 0) {
 301                         deviceCapabilitiesInfo->inputKeyboard = false;
 302                     } else {
 303                         deviceCapabilitiesInfo->inputKeyboard = true;
 304                     }
 305                     free(inputKeyboard);
 306                 }
 307             }
 308             return convert.toJSValueRef(deviceCapabilitiesInfo->inputKeyboardLayout);
 309         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_WIFI)) {
 310             bool wifi = false;
 311             if (system_info_get_value_bool(SYSTEM_INFO_KEY_WIFI_SUPPORTED, &wifi) == SYSTEM_INFO_ERROR_NONE) {
 312                 LoggerD("wifi : " << wifi);
 313                 deviceCapabilitiesInfo->wifi = wifi;
 314             }
 315             return convert.toJSValueRef(deviceCapabilitiesInfo->wifi);
 316         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_WIFIDIRECT)) {
 317             bool wifiDirect = false;
 318             if (system_info_get_value_bool(SYSTEM_INFO_KEY_WIFI_DIRECT_SUPPORTED, &wifiDirect) == SYSTEM_INFO_ERROR_NONE) {
 319                 LoggerD("wifiDirect : " << wifiDirect);
 320                 deviceCapabilitiesInfo->wifiDirect = wifiDirect;
 321             }
 322             return convert.toJSValueRef(deviceCapabilitiesInfo->wifiDirect);
 323         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_OPENGLES)) {
 324             char* openglesVersion = NULL;
 325             if (system_info_get_value_string(SYSTEM_INFO_KEY_OPENGLES_VERSION, &openglesVersion) == SYSTEM_INFO_ERROR_NONE) {
 326                 if (openglesVersion!= NULL) {
 327                     LoggerD("openglesVersion : " << openglesVersion);
 328                     deviceCapabilitiesInfo->opengles = true;
 329                     free(openglesVersion);
 330                 }
 331             }
 332             return convert.toJSValueRef(deviceCapabilitiesInfo->opengles);
 333         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_OPENGLES_TEXTURE_FORMAT)) {
 334             char* textureFormat = NULL;
 335             if (system_info_get_value_string(SYSTEM_INFO_KEY_OPENGLES_TEXTURE_FORMAT, &textureFormat) == SYSTEM_INFO_ERROR_NONE) {
 336                 if (textureFormat!= NULL) {
 337                     LoggerD("textureFormat : " << textureFormat);
 338                     deviceCapabilitiesInfo->openglestextureFormat = textureFormat;
 339                     free(textureFormat);
 340                 }
 341             }
 342             return convert.toJSValueRef(deviceCapabilitiesInfo->openglestextureFormat);
 343         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_OPENGLESVERSION1_1)) {
 344             char* openglesVersion = NULL;
 345             if (system_info_get_value_string(SYSTEM_INFO_KEY_OPENGLES_VERSION, &openglesVersion) == SYSTEM_INFO_ERROR_NONE) {
 346                 if (openglesVersion!= NULL) {
 347                     LoggerD("openglesVersion : " << openglesVersion);
 348                     if (strcmp(openglesVersion, "1.1") == 0) {
 349                         deviceCapabilitiesInfo->openglesVersion1_1 = true;
 350                     } else if (strcmp(openglesVersion, "1.1/2.0") == 0) {
 351                         deviceCapabilitiesInfo->openglesVersion1_1 = true;
 352                     }
 353                     free(openglesVersion);
 354                 }
 355             }
 356             return convert.toJSValueRef(deviceCapabilitiesInfo->openglesVersion1_1);
 357         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_OPENGLESVERSION2_0)) {
 358             char* openglesVersion = NULL;
 359             if (system_info_get_value_string(SYSTEM_INFO_KEY_OPENGLES_VERSION, &openglesVersion) == SYSTEM_INFO_ERROR_NONE) {
 360                 if (openglesVersion!= NULL) {
 361                     LoggerD("openglesVersion : " << openglesVersion);
 362                     if (strcmp(openglesVersion, "2.0") == 0) {
 363                         deviceCapabilitiesInfo->openglesVersion2_0 = true;
 364                     } else if (strcmp(openglesVersion, "1.1/2.0") == 0) {
 365                         deviceCapabilitiesInfo->openglesVersion2_0 = true;
 366                     }
 367                     free(openglesVersion);
 368                 }
 369             }
 370             return convert.toJSValueRef(deviceCapabilitiesInfo->openglesVersion2_0);
 371         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_FMRADIO)) {
 372             bool fmRadio = false;
 373             if (system_info_get_value_bool(SYSTEM_INFO_KEY_FMRADIO_SUPPORTED, &fmRadio) == SYSTEM_INFO_ERROR_NONE) {
 374                 LoggerD("fmRadio : " << fmRadio);
 375                 deviceCapabilitiesInfo->fmRadio = fmRadio;
 376             }
 377             return convert.toJSValueRef(deviceCapabilitiesInfo->fmRadio);
 378         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PLATFORMVERSION)) {
 379             AceSecurityStatus status = SYSTEMINFO_CHECK_ACCESS(SYSTEMINFO_FUNCTION_API_GET_CAPABILITIES);
 380             TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 381             char* platformVersion = NULL;
 382             if (system_info_get_value_string(SYSTEM_INFO_KEY_TIZEN_VERSION, &platformVersion) == SYSTEM_INFO_ERROR_NONE) {
 383                 if (platformVersion) {
 384                     LoggerD("platformVersion : " << platformVersion);
 385                     deviceCapabilitiesInfo->platformVersion = platformVersion;
 386                     free(platformVersion);
 387                 }
 388             }
 389             return convert.toJSValueRef(deviceCapabilitiesInfo->platformVersion);
 390         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PLATFORMNAME)) {
 391             char* platformName = NULL;
 392             if (system_info_get_value_string(SYSTEM_INFO_KEY_PLATFORM_NAME, &platformName) == SYSTEM_INFO_ERROR_NONE) {
 393                 if (platformName) {
 394                     LoggerD("platformName : " << platformName);
 395                     deviceCapabilitiesInfo->platformName = platformName;
 396                     free(platformName);
 397                 }
 398             }
 399             return convert.toJSValueRef(deviceCapabilitiesInfo->platformName);
 400         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_WEBAPIVERSION)) {
 401             AceSecurityStatus status = SYSTEMINFO_CHECK_ACCESS(SYSTEMINFO_FUNCTION_API_GET_CAPABILITIES);
 402             TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 403
 404             std::ifstream file("/usr/etc/system-info.ini");
 405             std::string line;
 406             std::string webApiVersionMajor = "";
 407             std::string webApiVersionMinor = "";
 408
 409             if(!file) {
 410                 LoggerD("api/native version info file not found");
 411             } else {
 412                 while ((std::getline(file, line).rdstate() & (std::ifstream::failbit | std::ifstream::eofbit)) == 0) {
 413                     if (pcrecpp::RE("platform.web.api.version=(\\w+).(\\w+)").PartialMatch(line, &webApiVersionMajor, &webApiVersionMinor)) {
 414                         deviceCapabilitiesInfo->webApiVersion = webApiVersionMajor;
 415                         deviceCapabilitiesInfo->webApiVersion += ".";
 416                         deviceCapabilitiesInfo->webApiVersion += webApiVersionMinor;
 417                         LoggerD("web api version : " << deviceCapabilitiesInfo->webApiVersion);
 418                         break;
 419                     }
 420                 }
 421                 file.close();
 422             }
 423
 424             return convert.toJSValueRef(deviceCapabilitiesInfo->webApiVersion);
 425         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_NATIVEAPIVERSION)) {
 426             AceSecurityStatus status = SYSTEMINFO_CHECK_ACCESS(SYSTEMINFO_FUNCTION_API_GET_CAPABILITIES);
 427             TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 428
 429             std::ifstream file("/usr/etc/system-info.ini");
 430             std::string line;
 431             std::string nativeApiVersionMajor = "";
 432             std::string nativeApiVersionMinor = "";
 433
 434             if(!file) {
 435                 LoggerD("api/native version info file not found");
 436             } else {
 437                 while ((std::getline(file, line).rdstate() & (std::ifstream::failbit | std::ifstream::eofbit)) == 0) {
 438                     if (pcrecpp::RE("platform.native.api.version=(\\w+).(\\w+)").PartialMatch(line, &nativeApiVersionMajor, &nativeApiVersionMinor )) {
 439                         deviceCapabilitiesInfo->nativeApiVersion = nativeApiVersionMajor;
 440                         deviceCapabilitiesInfo->nativeApiVersion += ".";
 441                         deviceCapabilitiesInfo->nativeApiVersion += nativeApiVersionMinor;
 442                         LoggerD("native api version : " << deviceCapabilitiesInfo->nativeApiVersion);
 443                         break;
 444                     }
 445                 }
 446                 file.close();
 447             }
 448
 449             return convert.toJSValueRef(deviceCapabilitiesInfo->nativeApiVersion);
 450         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_CAMERAFRONT)) {
 451             bool cameraFront = false;
 452             if (system_info_get_value_bool(SYSTEM_INFO_KEY_FRONT_CAMERA_SUPPORTED, &cameraFront) == SYSTEM_INFO_ERROR_NONE) {
 453                 LoggerD("cameraFront : " << cameraFront);
 454                 deviceCapabilitiesInfo->cameraFront = cameraFront;
 455             }
 456             return convert.toJSValueRef(deviceCapabilitiesInfo->cameraFront);
 457         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_CAMERA)) {
 458             int cameraCount = 0;
 459             if (system_info_get_value_int(SYSTEM_INFO_KEY_CAMERA_COUNT, &cameraCount) == SYSTEM_INFO_ERROR_NONE) {
 460                 LoggerD("cameraCount : " << cameraCount);
 461                 if (cameraCount > 0) {
 462                     deviceCapabilitiesInfo->camera = true;
 463                 } else {
 464                     deviceCapabilitiesInfo->camera = false;
 465                 }
 466             }
 467             return convert.toJSValueRef(deviceCapabilitiesInfo->camera);
 468         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_CAMERAFRONTFLASH)) {
 469             bool cameraFrontFlash = false;
 470             if (system_info_get_value_bool(SYSTEM_INFO_KEY_FRONT_CAMERA_FLASH_SUPPORTED, &cameraFrontFlash) == SYSTEM_INFO_ERROR_NONE) {
 471                 LoggerD("cameraFrontFlash : " << cameraFrontFlash);
 472                 deviceCapabilitiesInfo->cameraFrontFlash = cameraFrontFlash;
 473             }
 474             return convert.toJSValueRef(deviceCapabilitiesInfo->cameraFrontFlash);
 475         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_CAMERABACK)) {
 476             bool cameraBack = false;
 477             if (system_info_get_value_bool(SYSTEM_INFO_KEY_BACK_CAMERA_SUPPORTED, &cameraBack) == SYSTEM_INFO_ERROR_NONE) {
 478                 LoggerD("cameraBack : " << cameraBack);
 479                 deviceCapabilitiesInfo->cameraBack = cameraBack;
 480             }
 481             return convert.toJSValueRef(deviceCapabilitiesInfo->cameraBack);
 482         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_CAMERABACKFLASH)) {
 483             bool cameraBackFlash = false;
 484             if (system_info_get_value_bool(SYSTEM_INFO_KEY_BACK_CAMERA_FLASH_SUPPORTED, &cameraBackFlash) == SYSTEM_INFO_ERROR_NONE) {
 485                 LoggerD("cameraBackFlash : " << cameraBackFlash);
 486                 deviceCapabilitiesInfo->cameraBackFlash = cameraBackFlash;
 487             }
 488             return convert.toJSValueRef(deviceCapabilitiesInfo->cameraBackFlash);
 489         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_LOCATION)) {
 490             bool location = false;
 491             bool locationGps = false;
 492             bool locationWps = false;
 493             if (system_info_get_value_bool(SYSTEM_INFO_KEY_GPS_SUPPORTED, &locationGps) == SYSTEM_INFO_ERROR_NONE) {
 494                 LoggerD("locationGps : " << locationGps);
 495             }
 496             if (system_info_get_value_bool(SYSTEM_INFO_KEY_WPS_SUPPORTED, &locationWps) == SYSTEM_INFO_ERROR_NONE) {
 497                 LoggerD("locationWps : " << locationWps);
 498             }
 499             if (locationGps || locationWps) {
 500                 location = true;
 501             }
 502             deviceCapabilitiesInfo->location = location;
 503             return convert.toJSValueRef(deviceCapabilitiesInfo->location);
 504         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_LOCATIONGPS)) {
 505             bool locationGps = false;
 506             if (system_info_get_value_bool(SYSTEM_INFO_KEY_GPS_SUPPORTED, &locationGps) == SYSTEM_INFO_ERROR_NONE) {
 507                 LoggerD("locationGps : " << locationGps);
 508                 deviceCapabilitiesInfo->locationGps = locationGps;
 509             }
 510             return convert.toJSValueRef(deviceCapabilitiesInfo->locationGps);
 511         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_LOCATIONWPS)) {
 512             bool locationWps = false;
 513             if (system_info_get_value_bool(SYSTEM_INFO_KEY_WPS_SUPPORTED, &locationWps) == SYSTEM_INFO_ERROR_NONE) {
 514                 LoggerD("locationWps : " << locationWps);
 515                 deviceCapabilitiesInfo->locationWps = locationWps;
 516             }
 517             return convert.toJSValueRef(deviceCapabilitiesInfo->locationWps);
 518         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_MICROPHONE)) {
 519             bool microphone = false;
 520             if (system_info_get_value_bool(SYSTEM_INFO_KEY_MICROPHONE_SUPPORTED, &microphone) == SYSTEM_INFO_ERROR_NONE) {
 521                 LoggerD("microphone : " << microphone);
 522                 deviceCapabilitiesInfo->microphone = microphone;
 523             }
 524             return convert.toJSValueRef(deviceCapabilitiesInfo->microphone);
 525         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_USBHOST)) {
 526             bool usbHost = false;
 527             if (system_info_get_value_bool(SYSTEM_INFO_KEY_USB_HOST_SUPPORTED, &usbHost) == SYSTEM_INFO_ERROR_NONE) {
 528                 LoggerD("usbHost : " << usbHost);
 529                 deviceCapabilitiesInfo->usbHost = usbHost;
 530             }
 531             return convert.toJSValueRef(deviceCapabilitiesInfo->usbHost);
 532         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_USBACCESSORY)) {
 533             bool usbAccessory = false;
 534             if (system_info_get_value_bool(SYSTEM_INFO_KEY_USB_ACCESSORY_SUPPORTED, &usbAccessory) == SYSTEM_INFO_ERROR_NONE) {
 535                 LoggerD("usbAccessory : " << usbAccessory);
 536                 deviceCapabilitiesInfo->usbAccessory = usbAccessory;
 537             }
 538             return convert.toJSValueRef(deviceCapabilitiesInfo->usbAccessory);
 539         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SCREENOUTPUTRCA)) {
 540             bool screenOutputRca = false;
 541             if (system_info_get_value_bool(SYSTEM_INFO_KEY_RCA_SUPPORTED, &screenOutputRca) == SYSTEM_INFO_ERROR_NONE) {
 542                 LoggerD("screenOutputRca : " << screenOutputRca);
 543                 deviceCapabilitiesInfo->screenOutputRca = screenOutputRca;
 544             }
 545             return convert.toJSValueRef(deviceCapabilitiesInfo->screenOutputRca);
 546         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SCREENOUTPUTHDMI)) {
 547             bool screenOutputHdmi = false;
 548             if (system_info_get_value_bool(SYSTEM_INFO_KEY_HDMI_SUPPORTED, &screenOutputHdmi) == SYSTEM_INFO_ERROR_NONE) {
 549                 LoggerD("screenOutputHdmi : " << screenOutputHdmi);
 550                 deviceCapabilitiesInfo->screenOutputHdmi = screenOutputHdmi;
 551             }
 552             return convert.toJSValueRef(deviceCapabilitiesInfo->screenOutputHdmi);
 553         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PLATFORMCORECPUARCH)) {
 554             char* platformCoreCpuArch = NULL;
 555             if (system_info_get_value_string(SYSTEM_INFO_KEY_CORE_CPU_ARCH, &platformCoreCpuArch) == SYSTEM_INFO_ERROR_NONE) {
 556                 if (platformCoreCpuArch) {
 557                     LoggerD("platformCoreCpuArch : " << platformCoreCpuArch);
 558                     deviceCapabilitiesInfo->platformCoreCpuArch = platformCoreCpuArch;
 559                     free(platformCoreCpuArch);
 560                 }
 561             }
 562             return convert.toJSValueRef(deviceCapabilitiesInfo->platformCoreCpuArch);
 563         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PLATFORMCOREFPUARCH)) {
 564             char* platformCoreFpuArch = NULL;
 565             if (system_info_get_value_string(SYSTEM_INFO_KEY_CORE_FPU_ARCH, &platformCoreFpuArch) == SYSTEM_INFO_ERROR_NONE) {
 566                 if (platformCoreFpuArch) {
 567                     LoggerD("platformCoreFpuArch : " << platformCoreFpuArch);
 568                     deviceCapabilitiesInfo->platformCoreFpuArch = platformCoreFpuArch;
 569                     free(platformCoreFpuArch);
 570                 }
 571             }
 572             return convert.toJSValueRef(deviceCapabilitiesInfo->platformCoreFpuArch);
 573         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SIPVOIP)) {
 574             bool sipVoip = false;
 575             if (system_info_get_value_bool(SYSTEM_INFO_KEY_SIP_VOIP_SUPPORTED, &sipVoip) == SYSTEM_INFO_ERROR_NONE) {
 576                 LoggerD("sipVoip : " << sipVoip);
 577                 deviceCapabilitiesInfo->sipVoip = sipVoip;
 578             }
 579             return convert.toJSValueRef(deviceCapabilitiesInfo->sipVoip);
 580         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_DUID)) {
 581             char* duid = NULL;
 582             if (system_info_get_value_string(SYSTEM_INFO_KEY_DEVICE_UUID, &duid) == SYSTEM_INFO_ERROR_NONE) {
 583                 if (duid) {
 584                     LoggerD("duid : " << duid);
 585                     deviceCapabilitiesInfo->duid = duid;
 586                     free(duid);
 587                 }
 588             }
 589             return convert.toJSValueRef(deviceCapabilitiesInfo->duid);
 590         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SPEECH_ROCOGNITION)) {
 591             bool speechRecognition = false;
 592             if (system_info_get_value_bool(SYSTEM_INFO_KEY_SPEECH_RECOGNITION_SUPPORTED, &speechRecognition) == SYSTEM_INFO_ERROR_NONE) {
 593                 LoggerD("speechRecognition : " << speechRecognition);
 594                 deviceCapabilitiesInfo->speechRecognition = speechRecognition;
 595             }
 596             return convert.toJSValueRef(deviceCapabilitiesInfo->speechRecognition);
 597         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SPEECH_SYNTHESIS)) {
 598             void* handle = dlopen("/usr/lib/libtts.so",RTLD_NOW);
 599             if(handle!=NULL) {
 600                 deviceCapabilitiesInfo->speechSynthesis = true;
 601             } else {
 602                 deviceCapabilitiesInfo->speechSynthesis = false;
 603             }
 604             LoggerD("speechSynthesis : " << deviceCapabilitiesInfo->speechSynthesis);
 605             return convert.toJSValueRef(deviceCapabilitiesInfo->speechSynthesis);
 606         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_ACCELEROMETER)) {
 607             bool isAccelerometer = false;
 608             if (sensor_is_supported(SENSOR_ACCELEROMETER, &isAccelerometer) == SENSOR_ERROR_NONE) {
 609                 LoggerD("accelerometer : " << isAccelerometer);
 610                 deviceCapabilitiesInfo->accelerometer = isAccelerometer;
 611             }
 612             return convert.toJSValueRef(deviceCapabilitiesInfo->accelerometer);
 613         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_ACCELEROMETER_WAKEUP)) {
 614             bool isAccelerometerWakeup = false;
 615             if (sensor_awake_is_supported(SENSOR_ACCELEROMETER, &isAccelerometerWakeup) == SENSOR_ERROR_NONE) {
 616                 LoggerD("isAccelerometerWakeup : " << isAccelerometerWakeup);
 617                 deviceCapabilitiesInfo->accelerometerWakeup = isAccelerometerWakeup;
 618             }
 619             return convert.toJSValueRef(deviceCapabilitiesInfo->accelerometerWakeup);
 620         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_BAROMETER)) {
 621             bool isBarometer = false;
 622             if (system_info_get_value_bool(SYSTEM_INFO_KEY_BAROMETER_SENSOR_SUPPORTED, &isBarometer) == SYSTEM_INFO_ERROR_NONE) {
 623                 LoggerD("barometer : " << isBarometer);
 624                 deviceCapabilitiesInfo->barometer = isBarometer;
 625             }
 626             return convert.toJSValueRef(deviceCapabilitiesInfo->barometer);
 627         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_BAROMETER_WAKEUP)) {
 628             return convert.toJSValueRef(deviceCapabilitiesInfo->barometerWakeup);
 629         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_GYROSCOPE)) {
 630             bool isGyroscope = false;
 631             if (sensor_is_supported(SENSOR_GYROSCOPE, &isGyroscope) == SENSOR_ERROR_NONE) {
 632                 LoggerD("gyroscope : " << isGyroscope);
 633                 deviceCapabilitiesInfo->gyroscope = isGyroscope;
 634             }
 635             return convert.toJSValueRef(deviceCapabilitiesInfo->gyroscope);
 636         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_GYROSCOPE_WAKEUP)) {
 637             bool isGyroscopeWakeup = false;
 638             if (sensor_awake_is_supported(SENSOR_GYROSCOPE, &isGyroscopeWakeup) == SENSOR_ERROR_NONE) {
 639                 LoggerD("isGyroscopeWakeup : " << isGyroscopeWakeup);
 640                 deviceCapabilitiesInfo->gyroscopeWakeup = isGyroscopeWakeup;
 641             }
 642             return convert.toJSValueRef(deviceCapabilitiesInfo->gyroscopeWakeup);
 643         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_MAGNETOMETER)) {
 644             bool isMagnetometer = false;
 645             if (sensor_is_supported(SENSOR_MAGNETIC, &isMagnetometer) == SENSOR_ERROR_NONE) {
 646                 LoggerD("magnetometer : " << isMagnetometer);
 647                 deviceCapabilitiesInfo->magnetometer = isMagnetometer;
 648             }
 649             return convert.toJSValueRef(deviceCapabilitiesInfo->magnetometer);
 650         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_MAGNETOMETER_WAKEUP)) {
 651             bool isMagnetometerWakeup = false;
 652             if (sensor_awake_is_supported(SENSOR_MAGNETIC, &isMagnetometerWakeup) == SENSOR_ERROR_NONE) {
 653                 LoggerD("isMagnetometerWakeup : " << isMagnetometerWakeup);
 654                 deviceCapabilitiesInfo->magnetometerWakeup = isMagnetometerWakeup;
 655             }
 656             return convert.toJSValueRef(deviceCapabilitiesInfo->magnetometerWakeup);
 657         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PHOTOMETER)) {
 658             bool isPhotometer = false;
 659             if (sensor_is_supported(SENSOR_LIGHT, &isPhotometer) == SENSOR_ERROR_NONE) {
 660                 LoggerD("isPhotometer : " << isPhotometer);
 661                 deviceCapabilitiesInfo->photometer = isPhotometer;
 662             }
 663             return convert.toJSValueRef(deviceCapabilitiesInfo->photometer);
 664         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PHOTOMETER_WAKEUP)) {
 665             bool isphotometerWakeup = false;
 666             if (sensor_awake_is_supported(SENSOR_LIGHT, &isphotometerWakeup) == SENSOR_ERROR_NONE) {
 667                 LoggerD("isphotometerWakeup : " << isphotometerWakeup);
 668                 deviceCapabilitiesInfo->photometerWakeup = isphotometerWakeup;
 669             }
 670             return convert.toJSValueRef(deviceCapabilitiesInfo->photometerWakeup);
 671         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PROXIMITY)) {
 672             bool isProximity = false;
 673             if (sensor_is_supported(SENSOR_PROXIMITY, &isProximity) == SENSOR_ERROR_NONE) {
 674                 LoggerD("proximity : " << isProximity);
 675                 deviceCapabilitiesInfo->proximity = isProximity;
 676             }
 677             return convert.toJSValueRef(deviceCapabilitiesInfo->proximity);
 678         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PROXIMITY_WAKEUP)) {
 679             bool isProximityWakeup = false;
 680             if (sensor_awake_is_supported(SENSOR_PROXIMITY, &isProximityWakeup) == SENSOR_ERROR_NONE) {
 681                 LoggerD("isProximityWakeup : " << isProximityWakeup);
 682                 deviceCapabilitiesInfo->proximityWakeup = isProximityWakeup;
 683             }
 684             return convert.toJSValueRef(deviceCapabilitiesInfo->proximityWakeup);
 685         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_TILTMETER)) {
 686             bool isTiltmeter = false;
 687             if (sensor_is_supported(SENSOR_MOTION_TILT, &isTiltmeter) == SENSOR_ERROR_NONE) {
 688                 LoggerD("isTiltmeter : " << isTiltmeter);
 689                 deviceCapabilitiesInfo->tiltmeter = isTiltmeter;
 690             }
 691             return convert.toJSValueRef(deviceCapabilitiesInfo->tiltmeter);
 692         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_TILTMETER_WAKEUP)) {
 693             bool isTiltmeterWakeup = false;
 694             if (sensor_awake_is_supported(SENSOR_MOTION_TILT, &isTiltmeterWakeup) == SENSOR_ERROR_NONE) {
 695                 LoggerD("isTiltmeterWakeup : " << isTiltmeterWakeup);
 696                 deviceCapabilitiesInfo->tiltmeterWakeup = isTiltmeterWakeup;
 697             }
 698             return convert.toJSValueRef(deviceCapabilitiesInfo->tiltmeterWakeup);
 699         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_DATA_ENCRYPTION)) {
 700             void* handle = dlopen("/usr/lib/libsqlite3.so.0",RTLD_NOW);
 701             if(handle != NULL) {
 702                 deviceCapabilitiesInfo->dataEncryption = true;
 703             } else {
 704                 deviceCapabilitiesInfo->dataEncryption = false;
 705             }
 706             LoggerD("dataEncryption : " << deviceCapabilitiesInfo->dataEncryption);
 707             return convert.toJSValueRef(deviceCapabilitiesInfo->dataEncryption);
 708         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_GRAPHICS_ACCELERATION)) {
 709             bool isGraphicsAccelerationSupported = false;
 710             if (system_info_get_value_bool(SYSTEM_INFO_KEY_GRAPHICS_HWACCEL_SUPPORTED , &isGraphicsAccelerationSupported) == SYSTEM_INFO_ERROR_NONE) {
 711                 LoggerD("graphicsAcceleration : " << isGraphicsAccelerationSupported);
 712                 deviceCapabilitiesInfo->graphicsAcceleration = isGraphicsAccelerationSupported;
 713             }
 714             return convert.toJSValueRef(deviceCapabilitiesInfo->graphicsAcceleration);
 715         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PUSH)) {
 716             deviceCapabilitiesInfo->push = isExist("/usr/bin/pushd");
 717             LoggerD("push : " << deviceCapabilitiesInfo->push);
 718             return convert.toJSValueRef(deviceCapabilitiesInfo->push);
 719         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_TELEPHONY)) {
 720             deviceCapabilitiesInfo->telephony = isExist("/usr/bin/telephony-daemon");
 721             LoggerD("telephony : " << deviceCapabilitiesInfo->telephony);
 722             return convert.toJSValueRef(deviceCapabilitiesInfo->telephony);
 723         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_TELEPHONY_MMS)) {
 724             bool telephonyMms = false;
 725             if (system_info_get_value_bool(SYSTEM_INFO_KEY_MMS_SUPPORTED, &telephonyMms) == SYSTEM_INFO_ERROR_NONE) {
 726                 LoggerD("telephonyMms : " << telephonyMms);
 727                 deviceCapabilitiesInfo->telephonyMms = telephonyMms;
 728             }
 729             return convert.toJSValueRef(deviceCapabilitiesInfo->telephonyMms);
 730         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_TELEPHONY_SMS)) {
 731             bool telephonySms = false;
 732             if (system_info_get_value_bool(SYSTEM_INFO_KEY_SMS_SUPPORTED, &telephonySms) == SYSTEM_INFO_ERROR_NONE) {
 733                 LoggerD("telephonySms : " << telephonySms);
 734                 deviceCapabilitiesInfo->telephonySms = telephonySms;
 735             }
 736             return convert.toJSValueRef(deviceCapabilitiesInfo->telephonySms);
 737         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SCREENSIZE_NORMAL)) {
 738             deviceCapabilitiesInfo->screenSizeNormal = getRegistry("screen.coordinate_system.size.normal");
 739             LoggerD("screenSizeNormal : " << deviceCapabilitiesInfo->screenSizeNormal);
 740             return convert.toJSValueRef(deviceCapabilitiesInfo->screenSizeNormal);
 741         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SCREENSIZE_480_800)) {
 742             deviceCapabilitiesInfo->screenSize480_800 = getRegistry("screen.coordinate_system.physical.normal_480x800");
 743             LoggerD("screenSize480_800 : " << deviceCapabilitiesInfo->screenSize480_800);
 744             return convert.toJSValueRef(deviceCapabilitiesInfo->screenSize480_800);
 745         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SCREENSIZE_720_1280)) {
 746             deviceCapabilitiesInfo->screenSize720_1280 = getRegistry("screen.coordinate_system.physical.normal_720x1280");
 747             LoggerD("screenSize720_1280 : " << deviceCapabilitiesInfo->screenSize720_1280);
 748             return convert.toJSValueRef(deviceCapabilitiesInfo->screenSize720_1280);
 749         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_AUTO_ROTATION)) {
 750             bool isAutoRotation = false;
 751             if (system_info_get_value_bool(SYSTEM_INFO_KEY_FEATURE_AUTO_ROTATION_SUPPORTED, &isAutoRotation) == SYSTEM_INFO_ERROR_NONE) {
 752                 LoggerD("auto rotation : " << isAutoRotation);
 753                 deviceCapabilitiesInfo->autoRotation = isAutoRotation;
 754             }
 755             return convert.toJSValueRef(deviceCapabilitiesInfo->autoRotation);
 756         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SHELL_APP_WIDGET)) {
 757             bool isShellAppWidgetSupported = false;
 758             pkgmgrinfo_pkginfo_h handle;
 759             if (pkgmgrinfo_pkginfo_get_pkginfo("gi2qxenosh",&handle) == PMINFO_R_OK) {
 760                 isShellAppWidgetSupported = true;
 761                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 762                 LoggerD("shellAppWidget : " << isShellAppWidgetSupported);
 763             }
 764             deviceCapabilitiesInfo->shellAppWidget = isShellAppWidgetSupported;
 765             return convert.toJSValueRef(deviceCapabilitiesInfo->shellAppWidget);
 766         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_VISION_IMAGE_RECOGNITION)) {
 767             deviceCapabilitiesInfo->visionImageRecognition = isExist("/usr/lib/osp/libarengine.so");
 768             LoggerD("visionImageRecognition : " << deviceCapabilitiesInfo->visionImageRecognition);
 769             return convert.toJSValueRef(deviceCapabilitiesInfo->visionImageRecognition);
 770         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_VISION_QRCODE_GENERATION)) {
 771             deviceCapabilitiesInfo->visionQrcodeGeneration = isExist("/usr/lib/osp/libarengine.so");
 772             LoggerD("visionQrcodeGeneration : " << deviceCapabilitiesInfo->visionQrcodeGeneration);
 773             return convert.toJSValueRef(deviceCapabilitiesInfo->visionQrcodeGeneration);
 774         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_VISION_QRCODE_RECOGNITION)) {
 775             deviceCapabilitiesInfo->visionQrcodeRecognition = isExist("/usr/lib/osp/libarengine.so");
 776             LoggerD("visionQrcodeRecognition : " << deviceCapabilitiesInfo->visionQrcodeRecognition);
 777             return convert.toJSValueRef(deviceCapabilitiesInfo->visionQrcodeRecognition);
 778         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_VISION_FACE_RECOGNITION)) {
 779             deviceCapabilitiesInfo->visionFaceRecognition = isExist("/usr/lib/osp/libarengine.so");
 780             LoggerD("visionFaceRecognition : " << deviceCapabilitiesInfo->visionFaceRecognition);
 781             return convert.toJSValueRef(deviceCapabilitiesInfo->visionFaceRecognition);
 782         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SECURE_ELEMENT)) {
 783             deviceCapabilitiesInfo->secureElement = isExist("/usr/bin/smartcard-daemon");
 784             LoggerD("secureElement : " << deviceCapabilitiesInfo->secureElement);
 785             return convert.toJSValueRef(deviceCapabilitiesInfo->secureElement);
 786         } else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_NATIVE_OSP_COMPATIBLE)) {
 787             deviceCapabilitiesInfo->nativeOspCompatible = getRegistry("platform.native.osp_compatible");
 788             LoggerD("nativeOspCompatible : " << deviceCapabilitiesInfo->nativeOspCompatible);
 789             return convert.toJSValueRef(deviceCapabilitiesInfo->nativeOspCompatible);
 790         }
 791     }
 792     Catch(Exception)
 793     {
 794         LoggerE("Exception: " << _rethrown_exception.GetMessage());
 795     }
 796     return JSValueMakeUndefined(context);
 797 }
 798
 799 bool JSDeviceCapabilitiesInfo::isExist(const char* path)
 800 {
 801     if (0 == access(path ,F_OK))
 802         return true;
 803     return false;
 804 }
 805
 806 bool JSDeviceCapabilitiesInfo::getRegistry(std::string key)
 807 {
 808     std::ifstream file("/usr/etc/system-info.ini");
 809     std::string line;
 810     std::string _key;
 811     _key.append(key);
 812     _key.append("=(\\w+)");
 813     std::string value = "";
 814     bool ret = false;
 815
 816     if(!file) {
 817         LoggerD("Registry  file not found");
 818     } else {
 819         while ((std::getline(file, line).rdstate() & (std::ifstream::failbit | std::ifstream::eofbit)) == 0) {
 820             if (pcrecpp::RE(_key).PartialMatch(line, &value)) {
 821                 LoggerD("Key[" << key << "] : " << value; );
 822                 if(0==value.compare("true")) {
 823                     ret = true;
 824                 } else {
 825                     ret = false;
 826                 }
 827                 break;
 828             }
 829         }
 830         file.close();
 831     }
 832     return ret;
 833 }
 834
 835 }
 836 }