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