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