src/Systeminfo/Systeminfo.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 <stddef.h>
  20 #include <cassert>
  21 #include <pcrecpp.h>
  22 #include <dpl/log/log.h>
  23 #include <math.h>
  24 #include <Commons/Exception.h>
  25 #include <CommonsJavaScript/Converter.h>
  26 #include <CommonsJavaScript/PrivateObject.h>
  27 #include "Systeminfo.h"
  28
  29 using namespace WrtDeviceApis::CommonsJavaScript;
  30 using namespace WrtDeviceApis::Commons;
  31 using namespace DPL;
  32
  33 namespace DeviceAPI {
  34 namespace Systeminfo {
  35
  36 namespace {
  37
  38 void BatteryValueCallback(keynode_t *node, void *event_ptr)
  39 {
  40     if(event_ptr) {
  41         ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_BATTERY);
  42     }
  43 }
  44
  45 void PeripheralValueCallback(keynode_t *node, void *event_ptr)
  46 {
  47     if(event_ptr) {
  48         ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_PERIPHERAL);
  49     }
  50 }
  51
  52 void DisplayValueCallback(keynode_t *node, void* event_ptr)
  53 {
  54     if(event_ptr) {
  55         ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_DISPLAY);
  56     }
  57 }
  58
  59 void NetworkTypeValueCallback(connection_type_e type, void* event_ptr)
  60 {
  61     if(event_ptr) {
  62         ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_NETWORK);
  63     }
  64 }
  65
  66 void NetworkValueCallback(const char* ipv4_address, const char* ipv6_address, void* event_ptr)
  67 {
  68     if(event_ptr) {
  69         ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_NETWORK_ALL);
  70     }
  71 }
  72
  73 static Eina_Bool StorageValueCallback(void* event_ptr)
  74 {
  75     if(event_ptr) {
  76         ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_STORAGE);
  77     }
  78     return ECORE_CALLBACK_RENEW;
  79 }
  80
  81 static Eina_Bool CpuValueCallback(void* event_ptr)
  82 {
  83     if(event_ptr) {
  84         ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_CPU);
  85     }
  86     return ECORE_CALLBACK_RENEW;
  87 }
  88
  89 void OrientationValueCallback(unsigned int event_type, sensor_event_data_t *event , void *event_ptr)
  90 {
  91     LogDebug("enter");
  92     if(event_ptr) {
  93         ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_DEVICE_ORIENTATION);
  94     }
  95 }
  96
  97 void localeChangedCallback(runtime_info_key_e key, void* event_ptr)
  98 {
  99     LogDebug("enter");
 100     if(event_ptr) {
 101         ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_LOCALE);
 102     }
 103 }
 104
 105 }
 106
 107 #define STORAGE_INTERNAL_PATH   "/opt/usr/media"
 108 #define STORAGE_SDCARD_PATH     "/opt/storage/sdcard"
 109 #define STORAGE_USBHOST_PATH    "/opt/storage/usb"
 110 #define DISPLAY_BRIGHTNESS_DIVIDE_VALUE 100
 111 #define WIFI_SIGNAL_STRENGTH_DIVIDE_VALUE 100
 112 #define CPU_POWER_DEVICE_VALUE          100
 113
 114 #define RADIAN_VALUE (57.2957)
 115
 116 enum {
 117     STORAGE_TYPE_UNKNOWN = 0,
 118     STORAGE_TYPE_INTERNAL = 1,
 119     STORAGE_TYPE_MMC = 2,
 120     STORAGE_TYPE_USBHOST = 3
 121 };
 122
 123 Systeminfo::OptionalProperty Systeminfo::m_Property;
 124
 125 Systeminfo::Systeminfo() : m_networkRegist(REGIST_NOT),
 126                         m_storageTimer(NULL),
 127                         m_cpuTimer(NULL),
 128                         m_sensorHandle(0),
 129                         m_connectionHandle(NULL)
 130 {
 131     EventMgrPtr eventMgrPtr(new EventMgr());
 132     m_EventMgrPtr = eventMgrPtr;
 133     if (m_Property.IsNull()) {
 134         mapProperties properties;
 135         properties["BATTERY"] = BasePropertyPtr(new Battery());
 136         m_Property = properties;
 137         (*m_Property)["CPU"] = BasePropertyPtr(new Cpu());
 138         (*m_Property)["STORAGE"] = BasePropertyPtr(new Storage());
 139         (*m_Property)["DISPLAY"] = BasePropertyPtr(new Display());
 140         (*m_Property)["NETWORK"] = BasePropertyPtr(new Network());
 141         (*m_Property)["WIFI_NETWORK"] = BasePropertyPtr(new WifiNetwork());
 142         (*m_Property)["CELLULAR_NETWORK"] = BasePropertyPtr(new CellularNetwork());
 143         (*m_Property)["SIM"] = BasePropertyPtr(new SIM());
 144         (*m_Property)["DEVICE_ORIENTATION"] = BasePropertyPtr(new DeviceOrientation());
 145         (*m_Property)["BUILD"] = BasePropertyPtr(new Build());
 146         (*m_Property)["LOCALE"] = BasePropertyPtr(new Locale());
 147         (*m_Property)["PERIPHERAL"] = BasePropertyPtr(new Peripheral());
 148     }
 149
 150     int ret = connection_create(&m_connectionHandle);
 151
 152         if (CONNECTION_ERROR_NONE == ret) {
 153                 LogDebug("Network Client registration success");
 154         } else {
 155                 LogDebug("Network Client registration success");
 156         m_connectionHandle = NULL;
 157     }
 158
 159     m_sensorHandle = sf_connect(ACCELEROMETER_SENSOR);
 160     if (m_sensorHandle < 0) {
 161         LogDebug ("sensor attach fail");
 162     } else {
 163         LogDebug("m_sensorHandle : " << m_sensorHandle);
 164         int state = sf_start(m_sensorHandle, 0);
 165         if(state < 0) {
 166             LogDebug("failed");
 167         }
 168     }
 169 }
 170
 171 Systeminfo::~Systeminfo()
 172 {
 173         int state = 0;
 174     if (m_storageTimer) {
 175         ecore_timer_freeze(m_storageTimer);
 176         ecore_timer_del(m_storageTimer);
 177         m_storageTimer = NULL;
 178     }
 179     if (m_cpuTimer) {
 180         ecore_timer_freeze(m_cpuTimer);
 181         ecore_timer_del(m_cpuTimer);
 182         m_cpuTimer = NULL;
 183     }
 184     m_EventMgrPtr->clearAllEvent();
 185
 186     if(m_connectionHandle != NULL) {
 187         LogDebug("Network Client deregistration success");
 188         connection_destroy(m_connectionHandle);
 189     } else {
 190         LogDebug("Network Client deregistration failed");
 191     }
 192
 193         state = sf_stop(m_sensorHandle);
 194         LogDebug("handle 1  state = " << state);
 195
 196         state = sf_disconnect(m_sensorHandle);
 197         LogDebug("handle  state =" << state);
 198 }
 199
 200 DeviceCapabilitiesPropertiesPtr Systeminfo::getCapabilities()
 201 {
 202     LogDebug("enter");
 203     DeviceCapabilitiesPropertiesPtr deviceCapabilities(new DeviceCapabilitiesProperties());
 204     bool bluetooth = false, nfc = false, wifi = false, wifiDirect = false, fmRadio = false, cameraFront = false,
 205         cameraFrontFlash = false, cameraBack = false, cameraBackFlash = false, isAccelerometer = false, isGyroscope = false,
 206         isMagnetometer = false, isProximity = false, location = false, locationGps = false, locationWps = false,
 207         microphone = false, usbHost = false, usbAccessory = false, screenOutputRca = false, screenOutputHdmi = false,
 208         sipVoip = false, speechRecognition = false, isBarometer = false;
 209     int multiTouchCount = 0;
 210     char* inputKeyboard = NULL;
 211     char* platformVersion = NULL;
 212     char* platformName = NULL;
 213     char* platformCoreCpuArch = NULL;
 214     char* platformCoreFpuArch = NULL;
 215     char* duid = NULL;
 216     char* openglesVersion = NULL;
 217
 218     if (system_info_get_value_bool(SYSTEM_INFO_KEY_BLUETOOTH_SUPPORTED, &bluetooth) == SYSTEM_INFO_ERROR_NONE) {
 219         LogDebug("bluetooth : " << bluetooth);
 220         deviceCapabilities->bluetooth = bluetooth;
 221     }
 222
 223     if (system_info_get_value_bool(SYSTEM_INFO_KEY_NFC_SUPPORTED, &nfc) == SYSTEM_INFO_ERROR_NONE) {
 224         LogDebug("nfc : " << nfc);
 225         deviceCapabilities->nfc = nfc;
 226     }
 227     if (system_info_get_value_int(SYSTEM_INFO_KEY_MULTI_POINT_TOUCH_COUNT, &multiTouchCount) == SYSTEM_INFO_ERROR_NONE) {
 228         LogDebug("multiTouchCount : " << multiTouchCount);
 229         deviceCapabilities->multiTouchCount = multiTouchCount;
 230     }
 231
 232     if (system_info_get_value_string(SYSTEM_INFO_KEY_KEYBOARD_TYPE, &inputKeyboard) == SYSTEM_INFO_ERROR_NONE) {
 233         if (inputKeyboard != NULL) {
 234             LogDebug("inputKeyboard : " << inputKeyboard);
 235             deviceCapabilities->inputKeyboard = inputKeyboard;
 236             free(inputKeyboard);
 237         }
 238     }
 239
 240     if (system_info_get_value_bool(SYSTEM_INFO_KEY_WIFI_SUPPORTED, &wifi) == SYSTEM_INFO_ERROR_NONE) {
 241         LogDebug("wifi : " << wifi);
 242         deviceCapabilities->wifi = wifi;
 243     }
 244
 245     if (system_info_get_value_bool(SYSTEM_INFO_KEY_WIFI_DIRECT_SUPPORTED, &wifiDirect) == SYSTEM_INFO_ERROR_NONE) {
 246         LogDebug("wifiDirect : " << wifiDirect);
 247         deviceCapabilities->wifiDirect = wifiDirect;
 248     }
 249
 250     if (system_info_get_value_string(SYSTEM_INFO_KEY_OPENGLES_VERSION, &openglesVersion) == SYSTEM_INFO_ERROR_NONE) {
 251         if (openglesVersion!= NULL) {
 252             LogDebug("openglesVersion : " << openglesVersion);
 253             if (strcmp(openglesVersion, "1.0") == 0) {
 254                 deviceCapabilities->openglesVersion1_1 = true;
 255                 deviceCapabilities->openglesVersion2_0 = false;
 256             } else if (strcmp(openglesVersion, "2.0") == 0) {
 257                 deviceCapabilities->openglesVersion1_1 = false;
 258                 deviceCapabilities->openglesVersion2_0 = true;
 259             } else if (strcmp(openglesVersion, "1.0/2.0") == 0) {
 260                 deviceCapabilities->openglesVersion1_1 = true;
 261                 deviceCapabilities->openglesVersion2_0 = true;
 262             }
 263             free(openglesVersion);
 264         }
 265     }
 266
 267     if (system_info_get_value_bool(SYSTEM_INFO_KEY_FMRADIO_SUPPORTED, &fmRadio) == SYSTEM_INFO_ERROR_NONE) {
 268         LogDebug("fmRadio : " << fmRadio);
 269         deviceCapabilities->fmRadio = fmRadio;
 270     }
 271
 272     if (system_info_get_value_string(SYSTEM_INFO_KEY_TIZEN_VERSION, &platformVersion) == SYSTEM_INFO_ERROR_NONE) {
 273         if (platformVersion) {
 274             LogDebug("platformVersion : " << platformVersion);
 275             deviceCapabilities->platformVersion = platformVersion;
 276             free(platformVersion);
 277         }
 278     }
 279
 280     if (system_info_get_value_string(SYSTEM_INFO_KEY_PLATFORM_NAME, &platformName) == SYSTEM_INFO_ERROR_NONE) {
 281         if (platformName) {
 282             LogDebug("platformName : " << platformName);
 283             deviceCapabilities->platformName = platformName;
 284             free(platformName);
 285         }
 286     }
 287
 288     if (system_info_get_value_bool(SYSTEM_INFO_KEY_FRONT_CAMERA_SUPPORTED, &cameraFront) == SYSTEM_INFO_ERROR_NONE) {
 289         LogDebug("cameraFront : " << cameraFront);
 290         deviceCapabilities->cameraFront = cameraFront;
 291     }
 292
 293     if (system_info_get_value_bool(SYSTEM_INFO_KEY_FRONT_CAMERA_FLASH_SUPPORTED, &cameraFrontFlash) == SYSTEM_INFO_ERROR_NONE) {
 294         LogDebug("cameraFrontFlash : " << cameraFrontFlash);
 295         deviceCapabilities->cameraFrontFlash = cameraFrontFlash;
 296     }
 297
 298     if (system_info_get_value_bool(SYSTEM_INFO_KEY_BACK_CAMERA_SUPPORTED, &cameraBack) == SYSTEM_INFO_ERROR_NONE) {
 299         LogDebug("cameraBack : " << cameraBack);
 300         deviceCapabilities->cameraBack = cameraBack;
 301     }
 302
 303     if (system_info_get_value_bool(SYSTEM_INFO_KEY_BACK_CAMERA_FLASH_SUPPORTED, &cameraBackFlash) == SYSTEM_INFO_ERROR_NONE) {
 304         LogDebug("cameraBackFlash : " << cameraBackFlash);
 305         deviceCapabilities->cameraBackFlash = cameraBackFlash;
 306     }
 307
 308     if (system_info_get_value_bool(SYSTEM_INFO_KEY_CPS_SUPPORTED, &location) == SYSTEM_INFO_ERROR_NONE) {
 309         LogDebug("location : " << location);
 310         deviceCapabilities->location = location;
 311     }
 312
 313     if (system_info_get_value_bool(SYSTEM_INFO_KEY_GPS_SUPPORTED, &locationGps) == SYSTEM_INFO_ERROR_NONE) {
 314         LogDebug("locationGps : " << locationGps);
 315         deviceCapabilities->locationGps = locationGps;
 316     }
 317
 318     if (system_info_get_value_bool(SYSTEM_INFO_KEY_WPS_SUPPORTED, &locationWps) == SYSTEM_INFO_ERROR_NONE) {
 319         LogDebug("locationWps : " << locationWps);
 320         deviceCapabilities->locationWps = locationWps;
 321     }
 322
 323     if (system_info_get_value_bool(SYSTEM_INFO_KEY_MICROPHONE_SUPPORTED, &microphone) == SYSTEM_INFO_ERROR_NONE) {
 324         LogDebug("microphone : " << microphone);
 325         deviceCapabilities->microphone = microphone;
 326     }
 327
 328     if (system_info_get_value_bool(SYSTEM_INFO_KEY_USB_HOST_SUPPORTED, &usbHost) == SYSTEM_INFO_ERROR_NONE) {
 329         LogDebug("usbHost : " << usbHost);
 330         deviceCapabilities->usbHost = usbHost;
 331     }
 332
 333     if (system_info_get_value_bool(SYSTEM_INFO_KEY_USB_ACCESSORY_SUPPORTED, &usbAccessory) == SYSTEM_INFO_ERROR_NONE) {
 334         LogDebug("usbAccessory : " << usbAccessory);
 335         deviceCapabilities->usbAccessory = usbAccessory;
 336     }
 337
 338     if (system_info_get_value_bool(SYSTEM_INFO_KEY_RCA_SUPPORTED, &screenOutputRca) == SYSTEM_INFO_ERROR_NONE) {
 339         LogDebug("screenOutputRca : " << screenOutputRca);
 340         deviceCapabilities->screenOutputRca = screenOutputRca;
 341     }
 342
 343     if (system_info_get_value_bool(SYSTEM_INFO_KEY_HDMI_SUPPORTED, &screenOutputHdmi) == SYSTEM_INFO_ERROR_NONE) {
 344         LogDebug("screenOutputHdmi : " << screenOutputHdmi);
 345         deviceCapabilities->screenOutputHdmi = screenOutputHdmi;
 346     }
 347
 348     if (system_info_get_value_string(SYSTEM_INFO_KEY_CORE_CPU_ARCH, &platformCoreCpuArch) == SYSTEM_INFO_ERROR_NONE) {
 349         if (platformCoreCpuArch) {
 350             LogDebug("platformCoreCpuArch : " << platformCoreCpuArch);
 351             deviceCapabilities->platformCoreCpuArch = platformCoreCpuArch;
 352             free(platformCoreCpuArch);
 353         }
 354     }
 355
 356     if (system_info_get_value_string(SYSTEM_INFO_KEY_CORE_FPU_ARCH, &platformCoreFpuArch) == SYSTEM_INFO_ERROR_NONE) {
 357         if (platformCoreFpuArch) {
 358             LogDebug("platformCoreFpuArch : " << platformCoreFpuArch);
 359             deviceCapabilities->platformCoreFpuArch = platformCoreFpuArch;
 360             free(platformCoreFpuArch);
 361         }
 362     }
 363
 364     if (system_info_get_value_bool(SYSTEM_INFO_KEY_SIP_VOIP_SUPPORTED, &sipVoip) == SYSTEM_INFO_ERROR_NONE) {
 365         LogDebug("sipVoip : " << sipVoip);
 366         deviceCapabilities->sipVoip = sipVoip;
 367     }
 368
 369     if (system_info_get_value_string(SYSTEM_INFO_KEY_DEVICE_UUID, &duid) == SYSTEM_INFO_ERROR_NONE) {
 370         if (duid) {
 371             LogDebug("duid : " << duid);
 372             deviceCapabilities->duid = duid;
 373             free(duid);
 374         }
 375     }
 376
 377     if (system_info_get_value_bool(SYSTEM_INFO_KEY_SPEECH_RECOGNITION_SUPPORTED, &speechRecognition) == SYSTEM_INFO_ERROR_NONE) {
 378         LogDebug("speechRecognition : " << speechRecognition);
 379         deviceCapabilities->speechRecognition = speechRecognition;
 380     }
 381
 382     if (system_info_get_value_bool(SYSTEM_INFO_KEY_BAROMETER_SENSOR_SUPPORTED, &isBarometer) == SYSTEM_INFO_ERROR_NONE) {
 383         LogDebug("barometer : " << isBarometer);
 384         deviceCapabilities->barometer = isBarometer;
 385     }
 386
 387     if (sensor_is_supported(SENSOR_ACCELEROMETER, &isAccelerometer) == SENSOR_ERROR_NONE) {
 388         LogDebug("accelerometer : " << isAccelerometer);
 389         deviceCapabilities->accelerometer = isAccelerometer;
 390     }
 391
 392     if (sensor_is_supported(SENSOR_MAGNETIC, &isMagnetometer) == SENSOR_ERROR_NONE) {
 393         LogDebug("magnetometer : " << isMagnetometer);
 394         deviceCapabilities->magnetometer = isMagnetometer;
 395     }
 396
 397     if (sensor_is_supported(SENSOR_GYROSCOPE, &isGyroscope) == SENSOR_ERROR_NONE) {
 398         LogDebug("gyroscope : " << isGyroscope);
 399         deviceCapabilities->gyroscope = isGyroscope;
 400     }
 401
 402     if (sensor_is_supported(SENSOR_PROXIMITY, &isProximity) == SENSOR_ERROR_NONE) {
 403         LogDebug("proximity : " << isProximity);
 404         deviceCapabilities->proximity = isProximity;
 405     }
 406
 407     std::ifstream file("/usr/etc/system-info.ini");
 408     std::string line;
 409     std::string webApiVersionMajor = "";
 410     std::string webApiVersionMinor = "";
 411     std::string nativeApiVersionMajor = "";
 412     std::string nativeApiVersionMinor = "";
 413
 414     if(!file) {
 415         LogDebug("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.native.api.version=(\\w+).(\\w+)").PartialMatch(line, &nativeApiVersionMajor, &nativeApiVersionMinor )) {
 419                 deviceCapabilities->nativeApiVersion = nativeApiVersionMajor;
 420                 deviceCapabilities->nativeApiVersion += ".";
 421                 deviceCapabilities->nativeApiVersion += nativeApiVersionMinor;
 422                 LogDebug("native api version : " << deviceCapabilities->nativeApiVersion);
 423                 break;
 424             }
 425         }
 426         while ((std::getline(file, line).rdstate() & (std::ifstream::failbit | std::ifstream::eofbit)) == 0) {
 427             if (pcrecpp::RE("platform.web.api.version=(\\w+).(\\w+)").PartialMatch(line, &webApiVersionMajor, &webApiVersionMinor)) {
 428                 deviceCapabilities->webApiVersion = webApiVersionMajor;
 429                 deviceCapabilities->webApiVersion += ".";
 430                 deviceCapabilities->webApiVersion += webApiVersionMinor;
 431                 LogDebug("web api version : " << deviceCapabilities->webApiVersion);
 432                 break;
 433             }
 434         }
 435         file.close();
 436     }
 437
 438     return deviceCapabilities;
 439 }
 440
 441 void Systeminfo::get(const EventGetSysteminfoPtr& event)
 442 {
 443     EventRequestReceiver<EventGetSysteminfo>::PostRequest(event);
 444 }
 445
 446 void Systeminfo::watch(const EventWatchSysteminfoPtr& event)
 447 {
 448     if(event->getWatchType() == WATCH_TYPE_UNKNOWN) {
 449         LogDebug("watch method is not supported");
 450         event->setId(-1);
 451         return;
 452     }
 453
 454     event->setSysteminfoPtr(this);
 455     m_EventMgrPtr->addEvent(event, event->getWatchType());
 456
 457     EventRequestReceiver<EventWatchSysteminfo>::PostRequest(event);
 458 }
 459
 460 void Systeminfo::clearWatch(const long id)
 461 {
 462     if (id < 1) {
 463         Throw(InvalidArgumentException);
 464     } else {
 465         int watchType = m_EventMgrPtr->getWatchType(id);
 466         switch(watchType) {
 467             case WATCH_TYPE_BATTERY:
 468                 if ((m_EventMgrPtr->getEventBatteryList()).size() == 1) {
 469                     vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, BatteryValueCallback);
 470                     vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, BatteryValueCallback);
 471                 }
 472                 break;
 473             case WATCH_TYPE_DISPLAY:
 474                 if ((m_EventMgrPtr->getEventDisplayList()).size() == 1) {
 475                     vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, DisplayValueCallback);
 476                 }
 477                 break;
 478             case WATCH_TYPE_NETWORK:
 479                 if ((m_EventMgrPtr->getEventNetworkList()).size() == 1) {
 480                     connection_unset_type_changed_cb(m_connectionHandle);
 481                 }
 482                 break;
 483             case WATCH_TYPE_WIFINETWORK:
 484                 if ((m_EventMgrPtr->getEventWifiNetworkList()).size() == 1) {
 485                     if (m_networkRegist == REGIST_WIFI) {
 486                         connection_unset_ip_address_changed_cb(m_connectionHandle);
 487                         m_networkRegist = REGIST_NOT;
 488                     } else if (m_networkRegist== REGIST_ALL) {
 489                         m_networkRegist = REGIST_CELLULAR;
 490                     }
 491                 }
 492                 break;
 493             case WATCH_TYPE_CELLULARNETWORK:
 494                 if ((m_EventMgrPtr->getEventCellularNetworkList()).size() == 1) {
 495                     if (m_networkRegist == REGIST_CELLULAR) {
 496                         connection_unset_ip_address_changed_cb(m_connectionHandle);
 497                         m_networkRegist = REGIST_NOT;
 498                     } else if (m_networkRegist== REGIST_ALL) {
 499                         m_networkRegist = REGIST_WIFI;
 500                     }
 501                 }
 502                 break;
 503             case WATCH_TYPE_STORAGE:
 504                 if ((m_EventMgrPtr->getEventStorageList()).size() == 1) {
 505                     if (m_storageTimer) {
 506                         ecore_timer_freeze(m_storageTimer);
 507                         ecore_timer_del(m_storageTimer);
 508                         m_storageTimer = NULL;
 509                     }
 510                 }
 511                 break;
 512             case WATCH_TYPE_CPU:
 513                 if ((m_EventMgrPtr->getEventCpuList()).size() == 1) {
 514                     if (m_cpuTimer) {
 515                         ecore_timer_freeze(m_cpuTimer);
 516                         ecore_timer_del(m_cpuTimer);
 517                         m_cpuTimer = NULL;
 518                     }
 519                 }
 520                 break;
 521             case WATCH_TYPE_DEVICE_ORIENTATION:
 522                 if ((m_EventMgrPtr->getEventDeviceOrientationList()).size() == 1) {
 523                     int state = sf_unregister_event(m_sensorHandle, ACCELEROMETER_EVENT_ROTATION_CHECK);
 524                     if (state < 0) {
 525                         LogDebug("sf_unregister_event fail to gather data\n");
 526                     }
 527                 }
 528                 break;
 529             case WATCH_TYPE_LOCALE:
 530                 if ((m_EventMgrPtr->getEventLocaleList()).size() == 1) {
 531                     runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_LANGUAGE);
 532                     runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_REGION);
 533                 }
 534                 break;
 535             case WATCH_TYPE_PERIPHERAL:
 536                 if ((m_EventMgrPtr->getEventPeripheralList()).size() == 1) {
 537                     vconf_ignore_key_changed(VCONFKEY_MIRACAST_WFD_SOURCE_STATUS, PeripheralValueCallback);
 538                     vconf_ignore_key_changed(VCONFKEY_SYSMAN_HDMI, PeripheralValueCallback);
 539                 }
 540                 break;
 541             case WATCH_TYPE_UNKNOWN:
 542                 Throw(InvalidArgumentException);
 543                 break;
 544         }
 545         m_EventMgrPtr->removeEvent(id, watchType);
 546     }
 547 }
 548
 549 BasePropertyPtr Systeminfo::getBasePropertyPtr(JSContextRef context, JSValueRef property)
 550 {
 551     Converter converter(context);
 552     std::string l_property = converter.toString(property);
 553     mapProperties::iterator it = (*m_Property).find(l_property);
 554     if (it == (*m_Property).end()) {
 555         LogError("not existing property");
 556         Throw(InvalidArgumentException);
 557         return BasePropertyPtr(NULL);
 558     }
 559
 560     return it->second;
 561 }
 562
 563 void Systeminfo::getWatchValue(const int watchType)
 564 {
 565     if (watchType == WATCH_TYPE_BATTERY) {
 566         EventBatteryList eventList = m_EventMgrPtr->getEventBatteryList();
 567         for (EventBatteryList::iterator it = eventList.begin(); it != eventList.end(); it++) {
 568                 (*it)->getWatchValue();
 569             }
 570     } else if (watchType == WATCH_TYPE_DISPLAY) {
 571         EventDisplayList eventList = m_EventMgrPtr->getEventDisplayList();
 572         for (EventDisplayList::iterator it = eventList.begin(); it != eventList.end(); it++) {
 573             (*it)->getWatchValue();
 574         }
 575     } else if (watchType == WATCH_TYPE_NETWORK) {
 576         EventNetworkList eventList = m_EventMgrPtr->getEventNetworkList();
 577         for (EventNetworkList::iterator it = eventList.begin(); it != eventList.end(); it++) {
 578             (*it)->getWatchValue();
 579         }
 580     } else if (watchType == WATCH_TYPE_NETWORK_ALL) {
 581         EventWifiNetworkList eventListWifi = m_EventMgrPtr->getEventWifiNetworkList();
 582         EventWifiNetworkList eventListCellular = m_EventMgrPtr->getEventCellularNetworkList();
 583         if (eventListWifi.size() > 0) {
 584             for (EventWifiNetworkList::iterator it = eventListWifi.begin(); it != eventListWifi.end(); it++) {
 585                 (*it)->getWatchValue();
 586             }
 587         }
 588         if (eventListCellular.size() > 0) {
 589             for (EventCellularNetworkList::iterator it = eventListCellular.begin(); it != eventListCellular.end(); it++) {
 590                 (*it)->getWatchValue();
 591             }
 592         }
 593     } else if (watchType == WATCH_TYPE_CPU) {
 594         EventCpuList eventList = m_EventMgrPtr->getEventCpuList();
 595         for (EventCpuList::iterator it = eventList.begin(); it != eventList.end(); it++) {
 596             (*it)->getWatchValue();
 597         }
 598     } else if (watchType == WATCH_TYPE_STORAGE) {
 599         EventStorageList eventList = m_EventMgrPtr->getEventStorageList();
 600         for (EventStorageList::iterator it = eventList.begin(); it != eventList.end(); it++) {
 601         int storageCnt = 1;
 602         int sdcardState = 0;
 603         int usbhostState = 0;
 604         if(vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &sdcardState) == 0) {
 605             if(sdcardState == VCONFKEY_SYSMAN_MMC_MOUNTED) {
 606                 storageCnt++;
 607             }
 608         }
 609         if(vconf_get_int(VCONFKEY_SYSMAN_USB_HOST_STATUS, &usbhostState) == 0) {
 610             if(usbhostState == VCONFKEY_SYSMAN_USB_HOST_CONNECTED) {
 611                 storageCnt++;
 612             }
 613         }
 614         LogDebug("storage cnt : " << storageCnt);
 615             (*it)->getWatchValue(storageCnt);
 616         }
 617     }else if (watchType == WATCH_TYPE_DEVICE_ORIENTATION) {
 618         EventDeviceOrientationList eventList = m_EventMgrPtr->getEventDeviceOrientationList();
 619         for (EventDeviceOrientationList::iterator it = eventList.begin(); it != eventList.end(); it++) {
 620             (*it)->getWatchValue();
 621         }
 622     } else if (watchType == WATCH_TYPE_LOCALE) {
 623         EventLocaleList eventList = m_EventMgrPtr->getEventLocaleList();
 624         for (EventLocaleList::iterator it = eventList.begin(); it != eventList.end(); it++) {
 625             (*it)->getWatchValue();
 626         }
 627     } else if (watchType == WATCH_TYPE_PERIPHERAL) {
 628         EventPeripheralList eventList = m_EventMgrPtr->getEventPeripheralList();
 629         for (EventPeripheralList::iterator it = eventList.begin(); it != eventList.end(); it++) {
 630             (*it)->getWatchValue();
 631         }
 632     }
 633 }
 634
 635 connection_h Systeminfo::getConnectionHandle()
 636 {
 637     return m_connectionHandle;
 638 }
 639
 640 JSValueRef Systeminfo::getCpuValue(JSContextRef context)
 641 {
 642     LogDebug("enter");
 643     Converter converter(context);
 644
 645     CpuPropertiesPtr cpuPtr(new CpuProperties());
 646     FILE *fp = NULL;
 647     unsigned long long usr = 0, nice = 0, system = 0, idle = 0, cpuUsage = 0, diffIdle = 0, total = 0;
 648
 649     fp = fopen("/proc/stat", "r");
 650     if(fp == NULL) {
 651         return JSValueMakeNull(context);
 652     }
 653
 654     if (fscanf(fp, "%*s %lld %lld %lld %lld", &usr, &system, &nice, &idle) > 0) {
 655         total = usr + nice + system + idle - m_cpuInfo.usr - m_cpuInfo.nice - m_cpuInfo.system - m_cpuInfo.idle;
 656         diffIdle = idle-m_cpuInfo.idle;
 657         if ((total > 0) && (diffIdle > 0)) {
 658             cpuUsage = diffIdle * 100 / total;
 659         cpuPtr->load = (double)cpuUsage / 100.0;
 660         m_cpuInfo.usr = usr;
 661         m_cpuInfo.system = system;
 662         m_cpuInfo.nice = nice;
 663         m_cpuInfo.idle = idle;
 664             LogDebug("cpu load : " << cpuPtr->load);
 665         }
 666     }
 667
 668     fclose(fp);
 669     return JSCpuInfo::createJSObject(context, cpuPtr);
 670 }
 671
 672 void Systeminfo::OnRequestReceived(const EventGetSysteminfoPtr& event)
 673 {
 674     LogDebug("enter");
 675     event->processGetValue((void *)m_connectionHandle);
 676 }
 677
 678 void Systeminfo::OnRequestReceived(const EventWatchSysteminfoPtr& event)
 679 {
 680     WatchOption watchOption = event->getWatchOption();
 681
 682     event->switchToManualAnswer();
 683     event->setCancelAllowed(true);
 684
 685     switch(event->getWatchType()) {
 686         case WATCH_TYPE_BATTERY:
 687             if ((m_EventMgrPtr->getEventBatteryList()).size() == 1) {
 688                 vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY, BatteryValueCallback, (void *)this);
 689                 vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, BatteryValueCallback, (void *)this);
 690             }
 691             break;
 692         case WATCH_TYPE_DISPLAY:
 693             if ((m_EventMgrPtr->getEventDisplayList()).size() == 1) {
 694                 vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, DisplayValueCallback, (void *)this);
 695             }
 696             break;
 697         case WATCH_TYPE_NETWORK:
 698             if ((m_EventMgrPtr->getEventNetworkList()).size() == 1) {
 699                 connection_set_type_changed_cb(m_connectionHandle, NetworkTypeValueCallback, (void *)this);
 700             }
 701             break;
 702         case WATCH_TYPE_WIFINETWORK:
 703             if ((m_EventMgrPtr->getEventWifiNetworkList()).size() == 1) {
 704                 if (m_networkRegist == REGIST_NOT) {
 705                     connection_set_ip_address_changed_cb(m_connectionHandle, NetworkValueCallback, (void *)this);
 706                     m_networkRegist = REGIST_WIFI;
 707                 } else if (m_networkRegist== REGIST_CELLULAR) {
 708                     m_networkRegist = REGIST_ALL;
 709                 }
 710             }
 711             break;
 712         case WATCH_TYPE_CELLULARNETWORK:
 713             if ((m_EventMgrPtr->getEventCellularNetworkList()).size() == 1) {
 714                 if (m_networkRegist == REGIST_NOT) {
 715                     connection_set_ip_address_changed_cb(m_connectionHandle, NetworkValueCallback, (void *)this);
 716                     m_networkRegist = REGIST_CELLULAR;
 717                 } else if (m_networkRegist== REGIST_WIFI) {
 718                     m_networkRegist = REGIST_ALL;
 719                 }
 720             }
 721             break;
 722         case WATCH_TYPE_STORAGE:
 723             if ((m_EventMgrPtr->getEventStorageList()).size() == 1) {
 724                 if (!m_storageTimer) {
 725                     m_storageTimer = ecore_timer_add(1, StorageValueCallback, this);
 726                     ecore_timer_thaw(m_storageTimer);
 727                 }
 728             }
 729             break;
 730         case WATCH_TYPE_CPU:
 731             if ((m_EventMgrPtr->getEventCpuList()).size() == 1) {
 732                 if (!m_cpuTimer) {
 733                     m_cpuTimer = ecore_timer_add(1, CpuValueCallback, this);
 734                     ecore_timer_thaw(m_cpuTimer);
 735                 }
 736             }
 737             break;
 738         case WATCH_TYPE_DEVICE_ORIENTATION:
 739             LogDebug("regist sensor");
 740             if ((m_EventMgrPtr->getEventDeviceOrientationList()).size() == 1) {
 741                 int state = sf_register_event(m_sensorHandle, ACCELEROMETER_EVENT_ROTATION_CHECK, NULL, OrientationValueCallback, (void *)this);
 742                 if (state < 0) {
 743                     LogDebug("sensor_register_cb fail to gather data");
 744                 } else if (state == 0) {
 745                     LogDebug("sensor_register_cb success to gather data");
 746                 }
 747             } else {
 748                 LogDebug("already regist");
 749             }
 750             break;
 751         case WATCH_TYPE_LOCALE:
 752             if ((m_EventMgrPtr->getEventLocaleList()).size() == 1) {
 753                 runtime_info_set_changed_cb(RUNTIME_INFO_KEY_REGION, localeChangedCallback, (void *)this);
 754                 runtime_info_set_changed_cb(RUNTIME_INFO_KEY_LANGUAGE, localeChangedCallback, (void *)this);
 755             }
 756             break;
 757         case WATCH_TYPE_PERIPHERAL:
 758             if ((m_EventMgrPtr->getEventPeripheralList()).size() == 1) {
 759                 vconf_notify_key_changed(VCONFKEY_MIRACAST_WFD_SOURCE_STATUS, PeripheralValueCallback, (void *)this);
 760                 vconf_notify_key_changed(VCONFKEY_SYSMAN_HDMI, PeripheralValueCallback, (void *)this);
 761             }
 762             break;
 763     }
 764     event->processGetValue();
 765     event->setTimer();
 766 }
 767
 768 ////////////////////////////////////////////////////////////////////////////////////////
 769
 770 Systeminfo::EventMgr::EventMgr()
 771 {
 772 }
 773
 774 Systeminfo::EventMgr::~EventMgr()
 775 {
 776 }
 777
 778 void Systeminfo::EventMgr::clearAllEvent()
 779 {
 780     DPL::Mutex::ScopedLock lock(&m_synchro);
 781
 782     while (!m_eventBatteryList.empty()) {
 783         EventWatchSysteminfoPtr event = m_eventBatteryList.front();
 784         LogDebug("removing EventId=" << event->getId());
 785         event->clearWatch();
 786         m_eventBatteryList.pop_front();
 787     }
 788     while (!m_eventDisplayList.empty()) {
 789         EventWatchSysteminfoPtr event = m_eventDisplayList.front();
 790         LogDebug("removing EventId=" << event->getId());
 791         event->clearWatch();
 792         m_eventDisplayList.pop_front();
 793     }
 794     while (!m_eventWifiNetworkList.empty()) {
 795         EventWatchSysteminfoPtr event = m_eventWifiNetworkList.front();
 796         LogDebug("removing EventId=" << event->getId());
 797         event->clearWatch();
 798         m_eventWifiNetworkList.pop_front();
 799     }
 800     while (!m_eventCelluarNetworkList.empty()) {
 801         EventWatchSysteminfoPtr event = m_eventCelluarNetworkList.front();
 802         LogDebug("removing EventId=" << event->getId());
 803         event->clearWatch();
 804         m_eventCelluarNetworkList.pop_front();
 805     }
 806     while (!m_eventStorageList.empty()) {
 807         EventWatchSysteminfoPtr event = m_eventStorageList.front();
 808         LogDebug("removing EventId=" << event->getId());
 809         event->clearWatch();
 810         m_eventStorageList.pop_front();
 811     }
 812     while (!m_eventCpuList.empty()) {
 813         EventWatchSysteminfoPtr event = m_eventCpuList.front();
 814         LogDebug("removing EventId=" << event->getId());
 815         event->clearWatch();
 816         m_eventCpuList.pop_front();
 817     }
 818     while (!m_eventSimList.empty()) {
 819         EventWatchSysteminfoPtr event = m_eventSimList.front();
 820         LogDebug("removing EventId=" << event->getId());
 821         event->clearWatch();
 822         m_eventSimList.pop_front();
 823     }
 824     while (!m_eventDeviceOrientationList.empty()) {
 825         EventWatchSysteminfoPtr event = m_eventDeviceOrientationList.front();
 826         LogDebug("removing EventId=" << event->getId());
 827         event->clearWatch();
 828         m_eventDeviceOrientationList.pop_front();
 829     }
 830     while (!m_eventLocaleList.empty()) {
 831         EventWatchSysteminfoPtr event = m_eventLocaleList.front();
 832         LogDebug("removing EventId=" << event->getId());
 833         event->clearWatch();
 834         m_eventLocaleList.pop_front();
 835     }
 836     while (!m_eventPeripheralList.empty()) {
 837         EventWatchSysteminfoPtr event = m_eventPeripheralList.front();
 838         LogDebug("removing EventId=" << event->getId());
 839         event->clearWatch();
 840         m_eventPeripheralList.pop_front();
 841     }
 842 }
 843
 844 void Systeminfo::EventMgr::addEvent(const EventWatchSysteminfoPtr& arg, const int watchType)
 845 {
 846     DPL::Mutex::ScopedLock lock(&m_synchro);
 847
 848     if (watchType == WATCH_TYPE_BATTERY){
 849         m_eventBatteryList.push_back(arg);
 850         LogDebug("Event Battery list size=" << m_eventBatteryList.size());
 851     } else if (watchType == WATCH_TYPE_DISPLAY) {
 852         m_eventDisplayList.push_back(arg);
 853         LogDebug("Event display list size=" << m_eventDisplayList.size());
 854     } else if (watchType == WATCH_TYPE_WIFINETWORK) {
 855         m_eventWifiNetworkList.push_back(arg);
 856         LogDebug("Event wifi network list size=" << m_eventWifiNetworkList.size());
 857     } else if (watchType == WATCH_TYPE_CELLULARNETWORK) {
 858         m_eventCelluarNetworkList.push_back(arg);
 859         LogDebug("Event cellular network list size=" << m_eventCelluarNetworkList.size());
 860     } else if (watchType == WATCH_TYPE_STORAGE) {
 861         m_eventStorageList.push_back(arg);
 862         LogDebug("Event storage list size=" << m_eventStorageList.size());
 863     } else if (watchType == WATCH_TYPE_CPU) {
 864         m_eventCpuList.push_back(arg);
 865         LogDebug("Event cpu list size=" << m_eventCpuList.size());
 866     } else if (watchType == WATCH_TYPE_SIM) {
 867         m_eventSimList.push_back(arg);
 868         LogDebug("Event sim list size=" << m_eventSimList.size());
 869     } else if (watchType == WATCH_TYPE_DEVICE_ORIENTATION) {
 870         m_eventDeviceOrientationList.push_back(arg);
 871         LogDebug("Event device orientation list size=" << m_eventDeviceOrientationList.size());
 872     } else if (watchType == WATCH_TYPE_NETWORK) {
 873         m_eventNetworkList.push_back(arg);
 874         LogDebug("Event network list size=" << m_eventNetworkList.size());
 875     } else if (watchType == WATCH_TYPE_LOCALE) {
 876         m_eventLocaleList.push_back(arg);
 877         LogDebug("Event Locale list size=" << m_eventLocaleList.size());
 878     } else if (watchType == WATCH_TYPE_PERIPHERAL) {
 879         m_eventPeripheralList.push_back(arg);
 880         LogDebug("Event peripheral list size=" << m_eventPeripheralList.size());
 881     }
 882 }
 883
 884 void Systeminfo::EventMgr::removeEvent(WatchId id, const int watchType)
 885 {
 886     DPL::Mutex::ScopedLock lock(&m_synchro);
 887     LogDebug("Event id : " << id);
 888
 889     EventWatchSysteminfoPtr event(NULL);
 890
 891     LogDebug("trying to delete event, id=" << id);
 892
 893     if (watchType == WATCH_TYPE_BATTERY) {
 894         for (EventBatteryList::iterator it = m_eventBatteryList.begin(); it != m_eventBatteryList.end(); it++) {
 895             if (id == (*it)->getId()) {
 896                 event = *it;
 897                 break;
 898             }
 899         }
 900         if (!event) {
 901             LogError("event id not in the list, nothing to do");
 902             return;
 903         }
 904
 905         LogDebug("event Battery list size=" << m_eventBatteryList.size());
 906         m_eventBatteryList.remove(event);
 907         LogDebug( "event removed, event Battery list size=" << m_eventBatteryList.size());
 908     } else if (watchType == WATCH_TYPE_DISPLAY) {
 909         for (EventDisplayList::iterator it = m_eventDisplayList.begin(); it != m_eventDisplayList.end(); it++) {
 910             if (id == (*it)->getId()) {
 911                 event = *it;
 912                 break;
 913             }
 914         }
 915         if (!event) {
 916             LogError("event id not in the list, nothing to do");
 917             return;
 918         }
 919
 920         LogDebug("event display list size=" << m_eventDisplayList.size());
 921         m_eventDisplayList.remove(event);
 922         LogDebug( "event removed, event display list size=" << m_eventDisplayList.size());
 923     } else if (watchType == WATCH_TYPE_WIFINETWORK) {
 924         for (EventWifiNetworkList::iterator it = m_eventWifiNetworkList.begin(); it != m_eventWifiNetworkList.end(); it++) {
 925         if (id == (*it)->getId()) {
 926             event = *it;
 927             break;
 928         }
 929     }
 930     if (!event) {
 931         LogError("event id not in the list, nothing to do");
 932         return;
 933     }
 934
 935         LogDebug("event wifi network list size=" << m_eventWifiNetworkList.size());
 936         m_eventWifiNetworkList.remove(event);
 937         LogDebug( "event removed, event wifi network list size=" << m_eventCelluarNetworkList.size());
 938     } else if (watchType == WATCH_TYPE_CELLULARNETWORK) {
 939         for (EventCellularNetworkList::iterator it = m_eventCelluarNetworkList.begin(); it != m_eventCelluarNetworkList.end(); it++) {
 940             if (id == (*it)->getId()) {
 941                 event = *it;
 942                 break;
 943             }
 944         }
 945         if (!event) {
 946             LogError("event id not in the list, nothing to do");
 947             return;
 948         }
 949
 950         LogDebug("event cellular network list size=" << m_eventCelluarNetworkList.size());
 951         m_eventCelluarNetworkList.remove(event);
 952         LogDebug( "event removed, event cellular network list size=" << m_eventCelluarNetworkList.size());
 953     } else if (watchType == WATCH_TYPE_STORAGE) {
 954         for (EventStorageList::iterator it = m_eventStorageList.begin(); it != m_eventStorageList.end(); it++) {
 955             if (id == (*it)->getId()) {
 956                 event = *it;
 957                 break;
 958             }
 959         }
 960         if (!event) {
 961             LogError("event id not in the list, nothing to do");
 962             return;
 963         }
 964
 965         LogDebug("event storage list size=" << m_eventStorageList.size());
 966         m_eventStorageList.remove(event);
 967         LogDebug( "event removed, event storage list size=" << m_eventStorageList.size());
 968     } else if (watchType == WATCH_TYPE_CPU) {
 969         for (EventCpuList::iterator it = m_eventCpuList.begin(); it != m_eventCpuList.end(); it++) {
 970             if (id == (*it)->getId()) {
 971                 event = *it;
 972                 break;
 973             }
 974         }
 975         if (!event) {
 976             LogError("event id not in the list, nothing to do");
 977             return;
 978         }
 979
 980         LogDebug("event cpu list size=" << m_eventCpuList.size());
 981         m_eventCpuList.remove(event);
 982         LogDebug( "event removed, event cpu list size=" << m_eventCpuList.size());
 983     } else if (watchType == WATCH_TYPE_SIM) {
 984         for (EventSimList::iterator it = m_eventSimList.begin(); it != m_eventSimList.end(); it++) {
 985             if (id == (*it)->getId()) {
 986                 event = *it;
 987                 break;
 988             }
 989         }
 990         if (!event) {
 991             LogError("event id not in the list, nothing to do");
 992             return;
 993         }
 994
 995         LogDebug("event sim list size=" << m_eventSimList.size());
 996         m_eventSimList.remove(event);
 997         LogDebug( "event removed, event sim list size=" << m_eventSimList.size());
 998     } else if (watchType == WATCH_TYPE_DEVICE_ORIENTATION) {
 999         for (EventDeviceOrientationList::iterator it = m_eventDeviceOrientationList.begin(); it != m_eventDeviceOrientationList.end(); it++) {
1000             if (id == (*it)->getId()) {
1001                 event = *it;
1002                 break;
1003             }
1004         }
1005         if (!event) {
1006             LogError("event id not in the list, nothing to do");
1007             return;
1008         }
1009
1010         LogDebug("event device orientation list size=" << m_eventDeviceOrientationList.size());
1011         m_eventDeviceOrientationList.remove(event);
1012         LogDebug( "event removed, event device orientation list size=" << m_eventDeviceOrientationList.size());
1013     } else if (watchType == WATCH_TYPE_NETWORK) {
1014         for (EventNetworkList::iterator it = m_eventNetworkList.begin(); it != m_eventNetworkList.end(); it++) {
1015             if (id == (*it)->getId()) {
1016                 event = *it;
1017                 break;
1018             }
1019         }
1020         if (!event) {
1021             LogError("event id not in the list, nothing to do");
1022             return;
1023         }
1024
1025         LogDebug("event network list size=" << m_eventNetworkList.size());
1026         m_eventNetworkList.remove(event);
1027         LogDebug( "event removed, event network list size=" << m_eventNetworkList.size());
1028     } else if (watchType == WATCH_TYPE_LOCALE) {
1029         for (EventLocaleList::iterator it = m_eventLocaleList.begin(); it != m_eventLocaleList.end(); it++) {
1030             if (id == (*it)->getId()) {
1031                 event = *it;
1032                 break;
1033             }
1034         }
1035         if (!event) {
1036             LogError("event id not in the list, nothing to do");
1037             return;
1038         }
1039
1040         LogDebug("event Locale list size=" << m_eventLocaleList.size());
1041         m_eventLocaleList.remove(event);
1042         LogDebug( "event removed, event Locale list size=" << m_eventLocaleList.size());
1043     } else if (watchType == WATCH_TYPE_PERIPHERAL) {
1044         for (EventPeripheralList::iterator it = m_eventPeripheralList.begin(); it != m_eventPeripheralList.end(); it++) {
1045             if (id == (*it)->getId()) {
1046                 event = *it;
1047                 break;
1048             }
1049         }
1050         if (!event) {
1051             LogError("event id not in the list, nothing to do");
1052             return;
1053         }
1054
1055         LogDebug("event peripheral list size=" << m_eventPeripheralList.size());
1056         m_eventPeripheralList.remove(event);
1057         LogDebug( "event removed, event peripheral list size=" << m_eventPeripheralList.size());
1058     }
1059 }
1060
1061 const int Systeminfo::EventMgr::getWatchType(const long id)
1062 {
1063     DPL::Mutex::ScopedLock lock(&m_synchro);
1064
1065     EventWatchSysteminfoPtr event(NULL);
1066
1067     for (EventBatteryList::iterator it = m_eventBatteryList.begin(); it != m_eventBatteryList.end(); it++) {
1068         if (id == (*it)->getId()) {
1069             event = *it;
1070             break;
1071         }
1072     }
1073
1074     for (EventDisplayList::iterator it = m_eventDisplayList.begin(); it != m_eventDisplayList.end(); it++) {
1075         if (id == (*it)->getId()) {
1076             event = *it;
1077             break;
1078         }
1079     }
1080
1081     for (EventWifiNetworkList::iterator it = m_eventWifiNetworkList.begin(); it != m_eventWifiNetworkList.end(); it++) {
1082         if (id == (*it)->getId()) {
1083             event = *it;
1084             break;
1085         }
1086     }
1087
1088     for (EventCellularNetworkList::iterator it = m_eventCelluarNetworkList.begin(); it != m_eventCelluarNetworkList.end(); it++) {
1089         if (id == (*it)->getId()) {
1090             event = *it;
1091             break;
1092         }
1093     }
1094
1095     for (EventStorageList::iterator it = m_eventStorageList.begin(); it != m_eventStorageList.end(); it++) {
1096         if (id == (*it)->getId()) {
1097             event = *it;
1098             break;
1099         }
1100     }
1101
1102     for (EventCpuList::iterator it = m_eventCpuList.begin(); it != m_eventCpuList.end(); it++) {
1103         if (id == (*it)->getId()) {
1104             event = *it;
1105             break;
1106         }
1107     }
1108
1109     for (EventSimList::iterator it = m_eventSimList.begin(); it != m_eventSimList.end(); it++) {
1110         if (id == (*it)->getId()) {
1111             event = *it;
1112             break;
1113         }
1114     }
1115
1116     for (EventDeviceOrientationList::iterator it = m_eventDeviceOrientationList.begin(); it != m_eventDeviceOrientationList.end(); it++) {
1117         if (id == (*it)->getId()) {
1118             event = *it;
1119             break;
1120         }
1121     }
1122
1123     for (EventNetworkList::iterator it = m_eventNetworkList.begin(); it != m_eventNetworkList.end(); it++) {
1124         if (id == (*it)->getId()) {
1125             event = *it;
1126             break;
1127         }
1128     }
1129
1130     for (EventSimList::iterator it = m_eventSimList.begin(); it != m_eventSimList.end(); it++) {
1131         if (id == (*it)->getId()) {
1132             event = *it;
1133             break;
1134         }
1135     }
1136
1137     for (EventLocaleList::iterator it = m_eventLocaleList.begin(); it != m_eventLocaleList.end(); it++) {
1138         if (id == (*it)->getId()) {
1139             event = *it;
1140             break;
1141         }
1142     }
1143
1144     for (EventPeripheralList::iterator it = m_eventPeripheralList.begin(); it != m_eventPeripheralList.end(); it++) {
1145         if (id == (*it)->getId()) {
1146             event = *it;
1147             break;
1148         }
1149     }
1150
1151     if (!event) {
1152         LogError("event id not in the list, nothing to do");
1153         return WATCH_TYPE_UNKNOWN;
1154     }
1155
1156     return event->getWatchType();
1157 }
1158
1159 EventBatteryList Systeminfo::EventMgr::getEventBatteryList()
1160 {
1161     return m_eventBatteryList;
1162 }
1163
1164 EventDisplayList Systeminfo::EventMgr::getEventDisplayList()
1165 {
1166     return m_eventDisplayList;
1167 }
1168
1169 EventNetworkList Systeminfo::EventMgr::getEventNetworkList()
1170 {
1171     return m_eventNetworkList;
1172 }
1173
1174 EventWifiNetworkList Systeminfo::EventMgr::getEventWifiNetworkList()
1175 {
1176     return m_eventWifiNetworkList;
1177 }
1178
1179 EventCellularNetworkList Systeminfo::EventMgr::getEventCellularNetworkList()
1180 {
1181     return m_eventCelluarNetworkList;
1182 }
1183
1184 EventStorageList Systeminfo::EventMgr::getEventStorageList()
1185 {
1186     return m_eventStorageList;
1187 }
1188
1189 EventCpuList Systeminfo::EventMgr::getEventCpuList()
1190 {
1191     return m_eventCpuList;
1192 }
1193
1194 EventDeviceOrientationList Systeminfo::EventMgr::getEventDeviceOrientationList()
1195 {
1196     return m_eventDeviceOrientationList;
1197 }
1198
1199 EventSimList Systeminfo::EventMgr::getEventSimList()
1200 {
1201     return m_eventSimList;
1202 }
1203
1204 EventLocaleList Systeminfo::EventMgr::getEventLocaleList()
1205 {
1206     return m_eventLocaleList;
1207 }
1208
1209 EventPeripheralList Systeminfo::EventMgr::getEventPeripheralList()
1210 {
1211     return m_eventPeripheralList;
1212 }
1213
1214 ////////////////////////////////////////////////////////////////////////////////////////
1215
1216 PROPERTY_GET_SYSTEMINFO_DEFINITION(Battery) {
1217     BatteryPropertiesPtr BatteryPtr(new BatteryProperties());
1218     int value=0;
1219     int value2=0;
1220
1221     if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &value) != 0) {
1222         return JSValueMakeNull(context);
1223     } else {
1224         BatteryPtr->level = (double)(value)/CPU_POWER_DEVICE_VALUE;
1225     }
1226
1227     if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &value2) != 0) {
1228         return JSValueMakeNull(context);
1229     } else {
1230         BatteryPtr->isCharging = (value2 == 0) ? false : true;
1231     }
1232
1233     return JSBatteryInfo::createJSObject(context, BatteryPtr);
1234 }
1235
1236 PROPERTY_GET_SYSTEMINFO_DEFINITION(Cpu) {
1237     Converter converter(context);
1238
1239     CpuPropertiesPtr cpuPtr(new CpuProperties());
1240     FILE *fp = NULL;
1241     unsigned long long usr = 0, nice = 0, system = 0, idle = 0, total = 0, cpuUsage = 0;
1242
1243     fp = fopen("/proc/stat", "r");
1244     if(fp == NULL) {
1245         return JSValueMakeNull(context);
1246     }
1247
1248     if (fscanf(fp, "%*s %lld %lld %lld %lld", &usr, &system, &nice, &idle) > 0) {
1249         total = usr + nice + system + idle;
1250         if ((total > 0) && (idle > 0)) {
1251             cpuUsage = idle * 100 / total;
1252         cpuPtr->load = (double)cpuUsage / 100.0;
1253             LogDebug("cpu load : " << cpuPtr->load);
1254         }
1255     }
1256
1257     fclose(fp);
1258     return JSCpuInfo::createJSObject(context, cpuPtr);
1259 }
1260
1261 PROPERTY_GET_SYSTEMINFO_DEFINITION(Storage) {
1262     Converter converter(context);
1263     int sdcardState=0;
1264     int usbhostState=0;
1265     int storageCnt=0;
1266     struct statfs fs;
1267     StoragePropertiesPtr internal(new StorageProperties());
1268     StoragePropertiesPtr mmc(new StorageProperties());
1269     StoragePropertiesPtr usbhost(new StorageProperties());
1270     std::vector <JSObjectRef> storagelist;
1271
1272     if (statfs(STORAGE_INTERNAL_PATH, &fs) < 0) {
1273         return JSValueMakeNull(context);
1274     }
1275
1276     internal->type = "INTERNAL";
1277     internal->capacity = (unsigned long long)fs.f_bsize * (unsigned long long)fs.f_blocks;
1278     internal->availableCapacity = (unsigned long long)fs.f_bsize * (unsigned long long)fs.f_bavail;
1279     internal->isRemoveable = false;
1280     internal->isRemovable = false;
1281     storagelist.push_back(JSStorageInfo::createJSObject(context, internal));
1282     storageCnt++;
1283
1284     if(vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &sdcardState) == 0){
1285         if(sdcardState == VCONFKEY_SYSMAN_MMC_MOUNTED){
1286             storageCnt++;
1287             if (statfs(STORAGE_SDCARD_PATH, &fs) < 0) {
1288                 return JSValueMakeNull(context);
1289             }
1290             mmc->type = "MMC";
1291             mmc->capacity = (unsigned long long)fs.f_bsize * (unsigned long long)fs.f_blocks;
1292             mmc->availableCapacity = (unsigned long long)fs.f_bsize * (unsigned long long)fs.f_bavail;
1293             mmc->isRemoveable = true;
1294             mmc->isRemovable = true;
1295             storagelist.push_back(JSStorageInfo::createJSObject(context, mmc));
1296         }
1297     }
1298
1299     if(vconf_get_int(VCONFKEY_SYSMAN_USB_HOST_STATUS, &usbhostState) == 0) {
1300         if(usbhostState == VCONFKEY_SYSMAN_USB_HOST_CONNECTED) {
1301             storageCnt++;
1302             if (statfs(STORAGE_USBHOST_PATH, &fs) < 0)    {
1303                 return JSValueMakeNull(context);
1304             }
1305             usbhost->type = "USB_HOST";
1306             usbhost->capacity = (unsigned long long)fs.f_bsize * (unsigned long long)fs.f_blocks;
1307             usbhost->availableCapacity = (unsigned long long)fs.f_bsize * (unsigned long long)fs.f_bavail;
1308             usbhost->isRemoveable = true;
1309             usbhost->isRemovable = true;
1310             storagelist.push_back(JSStorageInfo::createJSObject(context, usbhost));
1311         }
1312     }
1313
1314     return JSObjectMakeArray(context, storageCnt, storagelist.data(), NULL);
1315 }
1316
1317 PROPERTY_GET_SYSTEMINFO_DEFINITION(Display) {
1318     Converter converter(context);
1319
1320     DisplayPropertiesPtr display(new DisplayProperties());
1321     int brightness=0, dotsPerInchX=0, dotsPerInchY=0, physicalW=0, physicalH=0, resolutionW=0, resolutionH=0;
1322
1323     if(vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &brightness) == 0) {
1324         display->brightness = (double)(brightness)/DISPLAY_BRIGHTNESS_DIVIDE_VALUE;
1325         LogDebug("brightness : " << display->brightness);
1326     }
1327
1328     if (system_info_get_value_int(SYSTEM_INFO_KEY_SCREEN_WIDTH, &resolutionW) == SYSTEM_INFO_ERROR_NONE) {
1329         display->resolutionWidth = resolutionW;
1330         LogDebug("resolutionWidth : " << display->resolutionWidth);
1331     }
1332     if (system_info_get_value_int(SYSTEM_INFO_KEY_SCREEN_HEIGHT, &resolutionH) == SYSTEM_INFO_ERROR_NONE) {
1333         display->resolutionHeight = resolutionH;
1334         LogDebug("resolutionHeight : " << display->resolutionHeight);
1335     }
1336     if (system_info_get_value_int(SYSTEM_INFO_KEY_SCREEN_DPI, &dotsPerInchX) == SYSTEM_INFO_ERROR_NONE) {
1337         display->dotsPerInchWidth = dotsPerInchX;
1338         LogDebug("dotsPerInchWidth : " << display->dotsPerInchWidth);
1339     }
1340     if (system_info_get_value_int(SYSTEM_INFO_KEY_SCREEN_DPI, &dotsPerInchY) == SYSTEM_INFO_ERROR_NONE) {
1341         display->dotsPerInchHeight = dotsPerInchY;
1342         LogDebug("dotsPerInchHeight : " << display->dotsPerInchHeight);
1343     }
1344     if (system_info_get_value_int(SYSTEM_INFO_KEY_PHYSICAL_SCREEN_HEIGHT, &physicalH) == SYSTEM_INFO_ERROR_NONE) {
1345         display->physicalHeight = physicalH;
1346         LogDebug("physicalHeight : " << display->physicalHeight);
1347     }
1348     if (system_info_get_value_int(SYSTEM_INFO_KEY_PHYSICAL_SCREEN_WIDTH, &physicalW) == SYSTEM_INFO_ERROR_NONE) {
1349         display->physicalWidth = physicalW;
1350         LogDebug("physicalWidth : " << display->physicalWidth);
1351     }
1352
1353     return JSDisplayInfo::createJSObject(context, display);
1354 }
1355
1356 PROPERTY_GET_SYSTEMINFO_DEFINITION(Network) {
1357     LogDebug("enter");
1358     Converter converter(context);
1359     NetworkPropertiesPtr Network(new NetworkProperties());
1360     connection_h connectionHandle = (connection_h)handle;
1361     connection_type_e connectionType;
1362     int networkType = 0;
1363
1364     if (connection_get_type(connectionHandle, &connectionType) != CONNECTION_ERROR_NONE) {
1365         LogDebug("get connection type is failed");
1366         return JSNetworkInfo::createJSObject(context, Network);
1367     }
1368
1369     if (connectionType == CONNECTION_TYPE_WIFI) {
1370         LogDebug("wifi network");
1371         Network->networkType= "WIFI";
1372     } else if (connectionType == CONNECTION_TYPE_CELLULAR) {
1373         if (vconf_get_int(VCONFKEY_TELEPHONY_SVCTYPE, &networkType) == 0) {
1374             if (networkType < VCONFKEY_TELEPHONY_SVCTYPE_2G) {
1375                 Network->networkType= "NONE";
1376             } else if (networkType == VCONFKEY_TELEPHONY_SVCTYPE_2G) {
1377                 Network->networkType= "2G";
1378             } else if (networkType == VCONFKEY_TELEPHONY_SVCTYPE_2G || networkType == VCONFKEY_TELEPHONY_SVCTYPE_2_5G_EDGE) {
1379                 Network->networkType= "2.5";
1380             } else if (networkType == VCONFKEY_TELEPHONY_SVCTYPE_3G || networkType == VCONFKEY_TELEPHONY_SVCTYPE_HSDPA) {
1381                 Network->networkType= "3G";
1382             } else if (networkType == VCONFKEY_TELEPHONY_SVCTYPE_LTE) {
1383                 Network->networkType= "4G";
1384             } else {
1385                 Network->networkType= "NONE";
1386             }
1387         }
1388     } else {
1389         Network->networkType= "NONE";
1390     }
1391
1392     return JSNetworkInfo::createJSObject(context, Network);
1393 }
1394
1395 PROPERTY_GET_SYSTEMINFO_DEFINITION(WifiNetwork) {
1396     Converter converter(context);
1397     WifiNetworkPropertiesPtr wifiNetwork(new WifiNetworkProperties());
1398     connection_h connectionHandle = (connection_h)handle;
1399     connection_type_e connectionType;
1400     connection_profile_h profileHandle = NULL;
1401     connection_address_family_e addressFamily = CONNECTION_ADDRESS_FAMILY_IPV4;
1402     char* ipAddr = NULL;
1403     char* essid = NULL;
1404     int rssi = 0;
1405
1406     if (connection_get_type(connectionHandle, &connectionType) != CONNECTION_ERROR_NONE) {
1407         return JSWifiNetworkInfo::createJSObject(context, wifiNetwork);
1408     }
1409
1410     if (connectionType == CONNECTION_TYPE_WIFI) {
1411         wifiNetwork->status = "ON";
1412     } else {
1413         wifiNetwork->status = "OFF";
1414         return JSWifiNetworkInfo::createJSObject(context, wifiNetwork);
1415     }
1416
1417     if (connection_get_current_profile(connectionHandle, &profileHandle) != CONNECTION_ERROR_NONE) {
1418         return JSWifiNetworkInfo::createJSObject(context, wifiNetwork);
1419     }
1420
1421     if (connection_profile_get_wifi_essid(profileHandle, &essid) == CONNECTION_ERROR_NONE) {
1422         wifiNetwork->ssid = essid;
1423         free(essid);
1424     }
1425
1426     if (connection_profile_get_ip_address(profileHandle, addressFamily, &ipAddr) == CONNECTION_ERROR_NONE) {
1427         wifiNetwork->ipAddress = ipAddr;
1428         free(ipAddr);
1429     }
1430
1431     if (connection_profile_get_wifi_rssi(profileHandle, &rssi) == CONNECTION_ERROR_NONE) {
1432         wifiNetwork->signalStrength = (double) rssi/WIFI_SIGNAL_STRENGTH_DIVIDE_VALUE;
1433     }
1434
1435     return JSWifiNetworkInfo::createJSObject(context, wifiNetwork);
1436 }
1437
1438 PROPERTY_GET_SYSTEMINFO_DEFINITION(CellularNetwork) {
1439     Converter converter(context);
1440     CellularNetworkPropertiesPtr cellularNetwork(new CellularNetworkProperties());
1441     connection_h connectionHandle = (connection_h)handle;
1442     connection_type_e connectionType;
1443     connection_profile_h profileHandle = NULL;
1444     connection_address_family_e addressFamily = CONNECTION_ADDRESS_FAMILY_IPV4;
1445     char* ipAddr = NULL;
1446     char* apn = NULL;
1447     char* imei = NULL;
1448     int plmn = 0, cellid = 0, lac = 0, isRoaming = 0, isFlightMode = 0;
1449
1450     if (vconf_get_int(VCONFKEY_TELEPHONY_PLMN, &plmn) == 0) {
1451         cellularNetwork->mcc = plmn / 100;
1452         cellularNetwork->mnc = plmn % 100;
1453     }
1454
1455     if (vconf_get_int(VCONFKEY_TELEPHONY_CELLID, &cellid) == 0) {
1456         cellularNetwork->cellId = cellid;
1457     }
1458
1459     if (vconf_get_int(VCONFKEY_TELEPHONY_LAC, &lac) == 0) {
1460         cellularNetwork->lac = lac;
1461     }
1462
1463     if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ROAM, &isRoaming) == 0) {
1464         if (isRoaming) {
1465             cellularNetwork->isRoaming = true;
1466         } else {
1467             cellularNetwork->isRoaming = false;
1468         }
1469     }
1470
1471     if (vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &isFlightMode) == 0) {
1472         if (isFlightMode) {
1473             cellularNetwork->isFlightMode = true;
1474         } else {
1475             cellularNetwork->isFlightMode = false;
1476         }
1477     }
1478
1479     if (connection_get_type(connectionHandle, &connectionType) != CONNECTION_ERROR_NONE) {
1480         return JSCellularNetworkInfo::createJSObject(context, cellularNetwork);
1481     }
1482
1483     if (connectionType == CONNECTION_TYPE_CELLULAR) {
1484         cellularNetwork->status = "ON";
1485         if (connection_get_current_profile(connectionHandle, &profileHandle) == CONNECTION_ERROR_NONE) {
1486             if (connection_profile_get_cellular_apn(profileHandle, &apn) == CONNECTION_ERROR_NONE) {
1487                 cellularNetwork->apn = apn;
1488                 free(apn);
1489             }
1490
1491             if (connection_profile_get_ip_address(profileHandle, addressFamily, &ipAddr) == CONNECTION_ERROR_NONE) {
1492                 cellularNetwork->ipAddress = ipAddr;
1493                 free(ipAddr);
1494             }
1495             connection_profile_destroy(profileHandle);
1496         }
1497     } else {
1498         cellularNetwork->status = "OFF";
1499         if (connection_get_default_cellular_service_profile(connectionHandle, CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET, &profileHandle) == CONNECTION_ERROR_NONE) {
1500             if (connection_profile_get_cellular_apn(profileHandle, &apn) == CONNECTION_ERROR_NONE) {
1501                 cellularNetwork->apn = apn;
1502                 free(apn);
1503             }
1504             connection_profile_destroy(profileHandle);
1505         }
1506     }
1507
1508     if (system_info_get_value_string(SYSTEM_INFO_KEY_MOBILE_DEVICE_ID, &imei) == SYSTEM_INFO_ERROR_NONE) {
1509         if (imei) {
1510             LogDebug("imei : " << imei);
1511             cellularNetwork->imei = imei;
1512             free(imei);
1513         }
1514     }
1515
1516     return JSCellularNetworkInfo::createJSObject(context, cellularNetwork);
1517 }
1518
1519 PROPERTY_GET_SYSTEMINFO_DEFINITION(SIM) {
1520     Converter converter(context);
1521     SIMPropertiesPtr SIM(new SIMProperties());
1522
1523     char* fullName = NULL;
1524     char* shortName = NULL;
1525     char* msisdn = NULL;
1526     char* iccId = NULL;
1527     char* mcc = NULL;
1528     char* mnc = NULL;
1529     char* msin = NULL;
1530     char* spn = NULL;
1531     int ret = SIM_ERROR_NONE;
1532
1533     ret = sim_get_cphs_operator_name(&fullName, &shortName);
1534     if (ret == SIM_ERROR_NONE) {
1535         if (fullName) {
1536             SIM->operatorName = fullName;
1537             LogDebug("operatorName : " << SIM->operatorName);
1538             free(fullName);
1539         } else if (shortName) {
1540             SIM->operatorName = shortName;
1541             LogDebug("operatorName : " << SIM->operatorName);
1542             free(shortName);
1543         }
1544     }
1545
1546     ret = sim_get_subscriber_number(&msisdn);
1547     if (ret == SIM_ERROR_NONE) {
1548         if (msisdn) {
1549             SIM->msisdn = msisdn;
1550             LogDebug("msisdn : " << SIM->msisdn);
1551             free(msisdn);
1552         }
1553     }
1554
1555     ret = sim_get_icc_id(&iccId);
1556     if (ret == SIM_ERROR_NONE) {
1557         if (iccId) {
1558             SIM->iccid = iccId;
1559             LogDebug("iccid : " << SIM->iccid);
1560             free(iccId);
1561         }
1562     }
1563
1564     ret = sim_get_mcc(&mcc);
1565     if (ret == SIM_ERROR_NONE) {
1566         if (mcc) {
1567             SIM->mcc = atoi(mcc);
1568             LogDebug("mcc : " << SIM->mcc);
1569             free(mcc);
1570         }
1571     }
1572
1573     ret = sim_get_mnc(&mnc);
1574     if (ret == SIM_ERROR_NONE) {
1575         if (mnc) {
1576             SIM->mnc = atoi(mnc);
1577             LogDebug("mnc : " << SIM->mnc);
1578             free(mnc);
1579         }
1580     }
1581
1582     ret = sim_get_msin(&msin);
1583     if (ret == SIM_ERROR_NONE) {
1584         if (msin) {
1585             SIM->msin = msin;
1586             LogDebug("msin : " << SIM->msin);
1587             free(msin);
1588         }
1589     }
1590
1591     ret = sim_get_spn(&spn);
1592     if (ret == SIM_ERROR_NONE) {
1593         if (spn) {
1594             SIM->spn = spn;
1595             LogDebug("spn : " << SIM->spn);
1596             free(spn);
1597         }
1598     }
1599
1600     return JSSIMInfo::createJSObject(context, SIM);
1601 }
1602
1603 PROPERTY_GET_SYSTEMINFO_DEFINITION(DeviceOrientation) {
1604     LogDebug("enter");
1605     Converter converter(context);
1606     DeviceOrientationPropertiesPtr deviceOrientation(new DeviceOrientationProperties());
1607
1608     unsigned long rotation = 0;
1609     int handleOrientaion = 0;
1610
1611     handleOrientaion = sf_connect(ACCELEROMETER_SENSOR);
1612     LogDebug("handleOrientaion : " << handleOrientaion);
1613     if (handleOrientaion < 0) {
1614         LogDebug ("sensor attach fail");
1615         return JSDeviceOrientationInfo::createJSObject(context, deviceOrientation);
1616     }
1617     int state = sf_start(handleOrientaion, 0);
1618     if(state < 0) {
1619         LogDebug("start failed");
1620     }
1621
1622     int ret_val = sf_check_rotation(&rotation);
1623     if (ret_val < 0) {
1624         LogDebug("sf_check_rotation fail to gather data\n");
1625     }
1626
1627     LogDebug(" rotation value = " << rotation);
1628
1629     switch (rotation) {
1630         case 0:
1631         case ROTATION_EVENT_0:
1632             LogDebug("my_callback_func received data (PORTRAIT_TOP|HEAD_CENTER)\n");
1633             deviceOrientation->status = "PORTRAIT_PRIMARY";
1634             break;
1635         case ROTATION_EVENT_90:
1636             LogDebug("my_callback_func received data (LANDSCAPE|HEAD_RIGHT)\n");
1637             deviceOrientation->status = "LANDSCAPE_PRIMARY";
1638             break;
1639         case ROTATION_EVENT_180:
1640             LogDebug("my_callback_func received data (PORTRAIT_BTM|HEAD_CENTER)\n");
1641             deviceOrientation->status = "PORTRAIT_SECONDARY";
1642             break;
1643         case ROTATION_EVENT_270:
1644             LogDebug("my_callback_func received data (LANDSCAPE|HEAD_LEFT)\n");
1645             deviceOrientation->status = "LANDSCAPE_SECONDARY";
1646             break;
1647         default:
1648             LogDebug(" received data unexpected\n");
1649             break;
1650     }
1651
1652         state = sf_stop(handleOrientaion);
1653         LogDebug("handleOrientaion 1  state = " << state);
1654
1655         state = sf_disconnect(handleOrientaion);
1656         LogDebug("handleOrientaion  state =" << state);
1657
1658     return JSDeviceOrientationInfo::createJSObject(context, deviceOrientation);
1659 }
1660
1661 PROPERTY_GET_SYSTEMINFO_DEFINITION(Build) {
1662     LogDebug("enter");
1663     Converter converter(context);
1664     BuildPropertiesPtr Build(new BuildProperties());
1665
1666     char* model = NULL;
1667     char* manufacturer = NULL;
1668
1669     if (system_info_get_value_string(SYSTEM_INFO_KEY_MODEL, &model) == SYSTEM_INFO_ERROR_NONE) {
1670         if (model != NULL) {
1671             LogDebug("model : " << model);
1672             Build->model = model;
1673             free(model);
1674         }
1675     }
1676
1677     if (system_info_get_value_string(SYSTEM_INFO_KEY_MANUFACTURER, &manufacturer) == SYSTEM_INFO_ERROR_NONE) {
1678         if (manufacturer != NULL) {
1679             LogDebug("manufacturer : " << manufacturer);
1680             Build->manufacturer = manufacturer;
1681             free(manufacturer);
1682         }
1683     }
1684
1685     return JSBuildInfo::createJSObject(context, Build);
1686 }
1687
1688 PROPERTY_GET_SYSTEMINFO_DEFINITION(Locale) {
1689     LogDebug("enter");
1690     Converter converter(context);
1691     LocalePropertiesPtr Locale(new LocaleProperties());
1692
1693     char* country = NULL;
1694     char* language = NULL;
1695
1696     if (runtime_info_get_value_string(RUNTIME_INFO_KEY_LANGUAGE, &language) == RUNTIME_INFO_ERROR_NONE) {
1697         if (language != NULL) {
1698             LogDebug("language : " << language);
1699             Locale->language = language;
1700             free(language);
1701         }
1702     }
1703
1704     if (runtime_info_get_value_string(RUNTIME_INFO_KEY_REGION, &country) == RUNTIME_INFO_ERROR_NONE) {
1705         LogDebug("country : " << country);
1706         char* token = NULL;
1707         char* countryTemp = NULL;
1708         token = strtok(country, ".");
1709         if (token != NULL) {
1710         countryTemp = strdup(token);
1711             if (countryTemp != NULL) {
1712         Locale->country = countryTemp;
1713             }
1714         if (countryTemp != NULL) {
1715             free(countryTemp);
1716         }
1717         if (country != NULL) {
1718             free(country);
1719         }
1720     }
1721     }
1722
1723     return JSLocaleInfo::createJSObject(context, Locale);
1724 }
1725
1726 PROPERTY_GET_SYSTEMINFO_DEFINITION(Peripheral) {
1727     Converter converter(context);
1728     PeripheralPropertiesPtr peripheral(new PeripheralProperties());
1729     int hdmiStatus = 0, wirelessDisplayStatus = 0 ;
1730
1731     if (vconf_get_int(VCONFKEY_MIRACAST_WFD_SOURCE_STATUS, &wirelessDisplayStatus) == 0) {
1732         switch(wirelessDisplayStatus) {
1733             case VCONFKEY_MIRACAST_WFD_SOURCE_ON:
1734                 peripheral->isVideoOutputOn = true;
1735                 break;
1736             default:
1737                 LogDebug("VideOutput status is off");
1738                 break;
1739         }
1740     }
1741
1742     if (vconf_get_int(VCONFKEY_SYSMAN_HDMI, &hdmiStatus) == 0) {
1743         switch(hdmiStatus) {
1744             case VCONFKEY_SYSMAN_HDMI_CONNECTED:
1745                 peripheral->isVideoOutputOn = true;
1746                 break;
1747             default:
1748                 LogDebug("VideOutput status is off");
1749                 break;
1750         }
1751     }
1752
1753     return JSPeripheralInfo::createJSObject(context, peripheral);
1754 }
1755
1756 }
1757 }