2 // Tizen Web Device API
3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
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
9 // http://www.apache.org/licenses/LICENSE-2.0
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.
21 #include <Commons/Exception.h>
22 #include <CommonsJavaScript/Converter.h>
23 #include <CommonsJavaScript/PrivateObject.h>
24 #include <TimeTracer.h>
25 #include "Systeminfo.h"
28 using namespace WrtDeviceApis::CommonsJavaScript;
29 using namespace WrtDeviceApis::Commons;
30 #define SIM_VALUE_MAX 4
33 namespace Systeminfo {
37 void BatteryValueCallback(keynode_t *node, void *event_ptr)
40 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_BATTERY);
44 void PeripheralValueCallback(keynode_t *node, void *event_ptr)
47 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_PERIPHERAL);
51 void CellularNetworkValueCallback(keynode_t *node, void *event_ptr)
54 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_CELLULARNETWORK);
58 void DisplayValueCallback(keynode_t *node, void* event_ptr)
61 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_DISPLAY);
65 void OrientationValueVconfCallback(keynode_t *node, void *event_ptr)
69 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_DEVICE_ORIENTATION);
73 void NetworkTypeValueCallback(connection_type_e type, void* event_ptr)
76 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_NETWORK);
80 void NetworkValueCallback(const char* ipv4_address, const char* ipv6_address, void* event_ptr)
83 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_NETWORK_ALL);
87 static Eina_Bool StorageValueCallback(void* event_ptr)
90 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_STORAGE);
92 return ECORE_CALLBACK_RENEW;
95 static Eina_Bool CpuValueCallback(void* event_ptr)
98 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_CPU);
100 return ECORE_CALLBACK_RENEW;
103 void OrientationValueCallback(unsigned int event_type, sensor_event_data_t *event , void *event_ptr)
106 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_DEVICE_ORIENTATION);
110 void localeChangedCallback(runtime_info_key_e key, void* event_ptr)
113 ((Systeminfo*)event_ptr)->getWatchValue(WATCH_TYPE_LOCALE);
117 void SimCphsValueCallback(TapiHandle *handle, int result, void *data, void *user_data)
119 TelSimAccessResult_t access_rt = (TelSimAccessResult_t)result;
120 TelSimCphsNetName_t *cphsInfo = (TelSimCphsNetName_t *)data;
122 LoggerD("access_rt : " << access_rt);
124 if (user_data != NULL){
125 SysteminfoAsyncPendingEvent *pendingEvent = (SysteminfoAsyncPendingEvent *)user_data;
126 Systeminfo *systeminfo = (Systeminfo *)pendingEvent->getThisObject();
127 EventGetSysteminfoPtr event = pendingEvent->getEvent();
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);
135 systeminfo->setSimValue(SIM_CPHS_VALUE, NULL, event);
138 systeminfo->setSimValue(SIM_CPHS_VALUE, NULL, event);
147 void SimMsisdnValueCallback(TapiHandle *handle, int result, void *data, void *user_data)
149 TelSimAccessResult_t access_rt = (TelSimAccessResult_t)result;
150 TelSimMsisdnList_t *msisdnInfo = (TelSimMsisdnList_t *)data;
152 LoggerD("access_rt : " << access_rt);
154 if (user_data != NULL){
155 SysteminfoAsyncPendingEvent *pendingEvent = (SysteminfoAsyncPendingEvent *)user_data;
156 Systeminfo *systeminfo = (Systeminfo *)pendingEvent->getThisObject();
157 EventGetSysteminfoPtr event = pendingEvent->getEvent();
159 if (access_rt == TAPI_SIM_ACCESS_SUCCESS) {
160 systeminfo->setSimValue(SIM_MSISDN_VALUE, (char *)msisdnInfo->list[0].num, event);
162 systeminfo->setSimValue(SIM_MSISDN_VALUE, NULL, event);
171 void SimIccidValueCallback(TapiHandle *handle, int result, void *data, void *user_data)
173 TelSimAccessResult_t access_rt = (TelSimAccessResult_t)result;
174 TelSimIccIdInfo_t *iccidInfo = (TelSimIccIdInfo_t *)data;
176 LoggerD("access_rt : " << access_rt);
178 if (user_data != NULL){
179 SysteminfoAsyncPendingEvent *pendingEvent = (SysteminfoAsyncPendingEvent *)user_data;
180 Systeminfo *systeminfo = (Systeminfo *)pendingEvent->getThisObject();
181 EventGetSysteminfoPtr event = pendingEvent->getEvent();
183 if (access_rt == TAPI_SIM_ACCESS_SUCCESS) {
184 systeminfo->setSimValue(SIM_ICCID_VALUE, (char *)iccidInfo->icc_num, event);
186 systeminfo->setSimValue(SIM_ICCID_VALUE, NULL, event);
195 void SimSpnValueCallback(TapiHandle *handle, int result, void *data, void *user_data)
197 TelSimAccessResult_t access_rt = (TelSimAccessResult_t)result;
198 TelSimSpn_t *spnInfo = (TelSimSpn_t *)data;
200 LoggerD("access_rt : " << access_rt);
202 if (user_data != NULL){
203 SysteminfoAsyncPendingEvent *pendingEvent = (SysteminfoAsyncPendingEvent *)user_data;
204 Systeminfo *systeminfo = (Systeminfo *)pendingEvent->getThisObject();
205 EventGetSysteminfoPtr event = pendingEvent->getEvent();
207 if (access_rt == TAPI_SIM_ACCESS_SUCCESS) {
208 systeminfo->setSimValue(SIM_SPN_VALUE, (char *)spnInfo->spn, event);
210 systeminfo->setSimValue(SIM_ICCID_VALUE, NULL, event);
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
228 #define RADIAN_VALUE (57.2957)
231 STORAGE_TYPE_UNKNOWN = 0,
232 STORAGE_TYPE_INTERNAL = 1,
233 STORAGE_TYPE_MMC = 2,
234 STORAGE_TYPE_USBHOST = 3
237 Systeminfo::OptionalProperty Systeminfo::m_Property;
239 Systeminfo::Systeminfo() : m_networkRegist(REGIST_NOT),
240 m_storageTimer(NULL),
243 m_connectionHandle(NULL)
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());
264 int ret = connection_create(&m_connectionHandle);
266 if (CONNECTION_ERROR_NONE == ret) {
267 LoggerD("Network Client registration success");
269 LoggerD("Network Client registration success");
270 m_connectionHandle = NULL;
273 m_sensorHandle = sf_connect(ACCELEROMETER_SENSOR);
274 if (m_sensorHandle < 0) {
275 LoggerD ("sensor attach fail");
277 LoggerD("m_sensorHandle : " << m_sensorHandle);
278 int state = sf_start(m_sensorHandle, 0);
284 m_tapiHandle = tel_init(0);
285 if (m_tapiHandle == NULL) {
286 LoggerE ("tel init fail");
290 Systeminfo::~Systeminfo()
293 if (m_storageTimer) {
294 ecore_timer_freeze(m_storageTimer);
295 ecore_timer_del(m_storageTimer);
296 m_storageTimer = NULL;
299 ecore_timer_freeze(m_cpuTimer);
300 ecore_timer_del(m_cpuTimer);
303 m_EventMgrPtr->clearAllEvent();
305 if(m_connectionHandle != NULL) {
306 LoggerD("Network Client deregistration success");
307 connection_destroy(m_connectionHandle);
309 LoggerD("Network Client deregistration failed");
312 if (m_tapiHandle != NULL) {
313 tel_deinit(m_tapiHandle);
316 state = sf_stop(m_sensorHandle);
317 LoggerD("handle 1 state = " << state);
319 state = sf_disconnect(m_sensorHandle);
320 LoggerD("handle state =" << state);
323 DeviceCapabilitiesPropertiesPtr Systeminfo::getCapabilities()
326 DeviceCapabilitiesPropertiesPtr deviceCapabilities(new DeviceCapabilitiesProperties());
327 return deviceCapabilities;
330 void Systeminfo::get(const EventGetSysteminfoPtr& event)
332 event->setTapiHandle((void*)m_tapiHandle);
333 EventRequestReceiver<EventGetSysteminfo>::PostRequest(event);
336 void Systeminfo::watch(const EventWatchSysteminfoPtr& event)
338 if(event->getWatchType() == WATCH_TYPE_UNKNOWN) {
339 LoggerD("watch method is not supported");
344 event->setSysteminfoPtr(this);
345 event->setTapiHandle((void*)m_tapiHandle);
346 m_EventMgrPtr->addEvent(event, event->getWatchType());
348 EventRequestReceiver<EventWatchSysteminfo>::PostRequest(event);
351 void Systeminfo::clearWatch(const long id)
354 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
356 int watchType = m_EventMgrPtr->getWatchType(id);
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);
364 case WATCH_TYPE_DISPLAY:
365 if ((m_EventMgrPtr->getEventDisplayList()).size() == 1) {
366 vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, DisplayValueCallback);
369 case WATCH_TYPE_NETWORK:
370 if ((m_EventMgrPtr->getEventNetworkList()).size() == 1) {
371 connection_unset_type_changed_cb(m_connectionHandle);
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;
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;
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;
408 if ((m_EventMgrPtr->getEventCpuList()).size() == 1) {
410 ecore_timer_freeze(m_cpuTimer);
411 ecore_timer_del(m_cpuTimer);
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);
421 LoggerD("sf_unregister_event fail to gather data\n");
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);
431 if (runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_REGION) != RUNTIME_INFO_ERROR_NONE) {
432 LoggerE("regist failed");
433 Throw(WrtDeviceApis::Commons::Exception);
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);
443 case WATCH_TYPE_UNKNOWN:
444 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
447 m_EventMgrPtr->removeEvent(id, watchType);
451 BasePropertyPtr Systeminfo::getBasePropertyPtr(JSContextRef context, JSValueRef property)
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);
465 void Systeminfo::getWatchValue(const int watchType)
467 LoggerD(" watch type : " << watchType);
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();
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();
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();
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();
492 if (eventListCellular.size() > 0) {
493 for (EventCellularNetworkList::iterator it = eventListCellular.begin(); it != eventListCellular.end(); it++) {
494 (*it)->getWatchValue();
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();
502 } else if (watchType == WATCH_TYPE_STORAGE) {
503 EventStorageList eventList = m_EventMgrPtr->getEventStorageList();
504 for (EventStorageList::iterator it = eventList.begin(); it != eventList.end(); it++) {
507 if(vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &sdcardState) == 0) {
508 if(sdcardState == VCONFKEY_SYSMAN_MMC_MOUNTED) {
512 LoggerD("storage cnt : " << storageCnt);
513 (*it)->getWatchValue(storageCnt);
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();
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();
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();
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();
540 connection_h Systeminfo::getConnectionHandle()
542 return m_connectionHandle;
545 JSValueRef Systeminfo::getCpuValue(JSContextRef context)
548 Converter converter(context);
550 CpuPropertiesPtr cpuPtr(new CpuProperties());
552 long long usr = 0, nice = 0, system = 0, idle = 0, cpuUsage = 0, diffIdle = 0, total = 0;
554 fp = fopen("/proc/stat", "r");
556 return JSValueMakeNull(context);
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;
566 m_cpuInfo.system = system;
567 m_cpuInfo.nice = nice;
568 m_cpuInfo.idle = idle;
569 LoggerD("cpu load : " << cpuPtr->load);
574 return JSCpuInfo::createJSObject(context, cpuPtr);
577 void Systeminfo::setSimValue(const int simAttribute, char* value, const EventGetSysteminfoPtr &event)
581 ret = event->addSimValueCnt();
583 ret = event->setSimValue(simAttribute, value);
586 if (ret == SIM_VALUE_MAX) {
587 event->makeSimObject();
588 EventRequestReceiver<EventGetSysteminfo>::ManualAnswer(event);
592 void Systeminfo::OnRequestReceived(const EventGetSysteminfoPtr& event)
596 if (strcmp(event->getProperty(), (const char*)"SIM") == 0) {
598 TelSimCardStatus_t simCardState;
599 TelSimImsiInfo_t imsi;
600 char* simState = NULL;
602 event->switchToManualAnswer();
603 event->setCancelAllowed(true);
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 :
611 case TAPI_SIM_STATUS_SIM_INITIALIZING :
612 simState = "INITIALIZING";
614 case TAPI_SIM_STATUS_SIM_INIT_COMPLETED :
617 case TAPI_SIM_STATUS_SIM_PIN_REQUIRED :
618 simState = "PIN_REQUIRED";
620 case TAPI_SIM_STATUS_SIM_PUK_REQUIRED :
621 simState = "PUK_REQUIRED";
623 case TAPI_SIM_STATUS_SIM_LOCK_REQUIRED :
624 case TAPI_SIM_STATUS_CARD_BLOCKED :
625 simState = "SIM_LOCKED";
627 case TAPI_SIM_STATUS_SIM_NCK_REQUIRED :
628 case TAPI_SIM_STATUS_SIM_NSCK_REQUIRED :
629 simState = "NETWORK_LOCKED";
631 case TAPI_SIM_STATUS_UNKNOWN :
632 case TAPI_SIM_STATUS_CARD_ERROR :
633 //case TAPI_SIM_STATUS_CARD_CRASHED :
635 simState = "UNKNOWN";
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);
644 LoggerE("get fail sim imsi");
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);
657 LoggerE("get fail sim state");
660 event->processGetValue((void *)m_connectionHandle);
664 void Systeminfo::OnRequestReceived(const EventWatchSysteminfoPtr& event)
666 WatchOption watchOption = event->getWatchOption();
668 event->switchToManualAnswer();
669 event->setCancelAllowed(true);
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);
678 case WATCH_TYPE_DISPLAY:
679 if ((m_EventMgrPtr->getEventDisplayList()).size() == 1) {
680 vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, DisplayValueCallback, (void *)this);
683 case WATCH_TYPE_NETWORK:
684 if ((m_EventMgrPtr->getEventNetworkList()).size() == 1) {
685 connection_set_type_changed_cb(m_connectionHandle, NetworkTypeValueCallback, (void *)this);
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;
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;
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);
721 if ((m_EventMgrPtr->getEventCpuList()).size() == 1) {
723 m_cpuTimer = ecore_timer_add(1, CpuValueCallback, this);
724 ecore_timer_thaw(m_cpuTimer);
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);
734 LoggerD("sensor_register_cb fail to gather data");
735 } else if (state == 0) {
736 LoggerD("sensor_register_cb success to gather data");
739 LoggerD("already regist");
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);
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);
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);
761 event->processGetValue();
765 ////////////////////////////////////////////////////////////////////////////////////////
767 Systeminfo::EventMgr::EventMgr()
771 Systeminfo::EventMgr::~EventMgr()
775 void Systeminfo::EventMgr::clearAllEvent()
777 DPL::Mutex::ScopedLock lock(&m_synchro);
779 while (!m_eventBatteryList.empty()) {
780 EventWatchSysteminfoPtr event = m_eventBatteryList.front();
781 LoggerD("removing EventId=" << event->getId());
783 m_eventBatteryList.pop_front();
785 while (!m_eventDisplayList.empty()) {
786 EventWatchSysteminfoPtr event = m_eventDisplayList.front();
787 LoggerD("removing EventId=" << event->getId());
789 m_eventDisplayList.pop_front();
791 while (!m_eventWifiNetworkList.empty()) {
792 EventWatchSysteminfoPtr event = m_eventWifiNetworkList.front();
793 LoggerD("removing EventId=" << event->getId());
795 m_eventWifiNetworkList.pop_front();
797 while (!m_eventCelluarNetworkList.empty()) {
798 EventWatchSysteminfoPtr event = m_eventCelluarNetworkList.front();
799 LoggerD("removing EventId=" << event->getId());
801 m_eventCelluarNetworkList.pop_front();
803 while (!m_eventStorageList.empty()) {
804 EventWatchSysteminfoPtr event = m_eventStorageList.front();
805 LoggerD("removing EventId=" << event->getId());
807 m_eventStorageList.pop_front();
809 while (!m_eventCpuList.empty()) {
810 EventWatchSysteminfoPtr event = m_eventCpuList.front();
811 LoggerD("removing EventId=" << event->getId());
813 m_eventCpuList.pop_front();
815 while (!m_eventSimList.empty()) {
816 EventWatchSysteminfoPtr event = m_eventSimList.front();
817 LoggerD("removing EventId=" << event->getId());
819 m_eventSimList.pop_front();
821 while (!m_eventDeviceOrientationList.empty()) {
822 EventWatchSysteminfoPtr event = m_eventDeviceOrientationList.front();
823 LoggerD("removing EventId=" << event->getId());
825 m_eventDeviceOrientationList.pop_front();
827 while (!m_eventLocaleList.empty()) {
828 EventWatchSysteminfoPtr event = m_eventLocaleList.front();
829 LoggerD("removing EventId=" << event->getId());
831 m_eventLocaleList.pop_front();
833 while (!m_eventPeripheralList.empty()) {
834 EventWatchSysteminfoPtr event = m_eventPeripheralList.front();
835 LoggerD("removing EventId=" << event->getId());
837 m_eventPeripheralList.pop_front();
841 void Systeminfo::EventMgr::addEvent(const EventWatchSysteminfoPtr& arg, const int watchType)
843 DPL::Mutex::ScopedLock lock(&m_synchro);
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());
881 void Systeminfo::EventMgr::removeEvent(WatchId id, const int watchType)
883 DPL::Mutex::ScopedLock lock(&m_synchro);
884 LoggerD("Event id : " << id);
886 EventWatchSysteminfoPtr event(NULL);
888 LoggerD("trying to delete event, id=" << id);
890 if (watchType == WATCH_TYPE_BATTERY) {
891 for (EventBatteryList::iterator it = m_eventBatteryList.begin(); it != m_eventBatteryList.end(); it++) {
892 if (id == (*it)->getId()) {
898 LoggerE("event id not in the list, nothing to do");
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()) {
913 LoggerE("event id not in the list, nothing to do");
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()) {
928 LoggerE("event id not in the list, nothing to do");
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()) {
943 LoggerE("event id not in the list, nothing to do");
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()) {
958 LoggerE("event id not in the list, nothing to do");
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()) {
973 LoggerE("event id not in the list, nothing to do");
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()) {
988 LoggerE("event id not in the list, nothing to do");
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()) {
1003 LoggerE("event id not in the list, nothing to do");
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()) {
1018 LoggerE("event id not in the list, nothing to do");
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()) {
1033 LoggerE("event id not in the list, nothing to do");
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()) {
1048 LoggerE("event id not in the list, nothing to do");
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());
1058 const int Systeminfo::EventMgr::getWatchType(const long id)
1060 DPL::Mutex::ScopedLock lock(&m_synchro);
1062 EventWatchSysteminfoPtr event(NULL);
1064 for (EventBatteryList::iterator it = m_eventBatteryList.begin(); it != m_eventBatteryList.end(); it++) {
1065 if (id == (*it)->getId()) {
1071 for (EventDisplayList::iterator it = m_eventDisplayList.begin(); it != m_eventDisplayList.end(); it++) {
1072 if (id == (*it)->getId()) {
1078 for (EventWifiNetworkList::iterator it = m_eventWifiNetworkList.begin(); it != m_eventWifiNetworkList.end(); it++) {
1079 if (id == (*it)->getId()) {
1085 for (EventCellularNetworkList::iterator it = m_eventCelluarNetworkList.begin(); it != m_eventCelluarNetworkList.end(); it++) {
1086 if (id == (*it)->getId()) {
1092 for (EventStorageList::iterator it = m_eventStorageList.begin(); it != m_eventStorageList.end(); it++) {
1093 if (id == (*it)->getId()) {
1099 for (EventCpuList::iterator it = m_eventCpuList.begin(); it != m_eventCpuList.end(); it++) {
1100 if (id == (*it)->getId()) {
1106 for (EventSimList::iterator it = m_eventSimList.begin(); it != m_eventSimList.end(); it++) {
1107 if (id == (*it)->getId()) {
1113 for (EventDeviceOrientationList::iterator it = m_eventDeviceOrientationList.begin(); it != m_eventDeviceOrientationList.end(); it++) {
1114 if (id == (*it)->getId()) {
1120 for (EventNetworkList::iterator it = m_eventNetworkList.begin(); it != m_eventNetworkList.end(); it++) {
1121 if (id == (*it)->getId()) {
1127 for (EventSimList::iterator it = m_eventSimList.begin(); it != m_eventSimList.end(); it++) {
1128 if (id == (*it)->getId()) {
1134 for (EventLocaleList::iterator it = m_eventLocaleList.begin(); it != m_eventLocaleList.end(); it++) {
1135 if (id == (*it)->getId()) {
1141 for (EventPeripheralList::iterator it = m_eventPeripheralList.begin(); it != m_eventPeripheralList.end(); it++) {
1142 if (id == (*it)->getId()) {
1149 LoggerE("event id not in the list, nothing to do");
1150 return WATCH_TYPE_UNKNOWN;
1153 return event->getWatchType();
1156 EventBatteryList Systeminfo::EventMgr::getEventBatteryList()
1158 return m_eventBatteryList;
1161 EventDisplayList Systeminfo::EventMgr::getEventDisplayList()
1163 return m_eventDisplayList;
1166 EventNetworkList Systeminfo::EventMgr::getEventNetworkList()
1168 return m_eventNetworkList;
1171 EventWifiNetworkList Systeminfo::EventMgr::getEventWifiNetworkList()
1173 return m_eventWifiNetworkList;
1176 EventCellularNetworkList Systeminfo::EventMgr::getEventCellularNetworkList()
1178 return m_eventCelluarNetworkList;
1181 EventStorageList Systeminfo::EventMgr::getEventStorageList()
1183 return m_eventStorageList;
1186 EventCpuList Systeminfo::EventMgr::getEventCpuList()
1188 return m_eventCpuList;
1191 EventDeviceOrientationList Systeminfo::EventMgr::getEventDeviceOrientationList()
1193 return m_eventDeviceOrientationList;
1196 EventSimList Systeminfo::EventMgr::getEventSimList()
1198 return m_eventSimList;
1201 EventLocaleList Systeminfo::EventMgr::getEventLocaleList()
1203 return m_eventLocaleList;
1206 EventPeripheralList Systeminfo::EventMgr::getEventPeripheralList()
1208 return m_eventPeripheralList;
1211 ////////////////////////////////////////////////////////////////////////////////////////
1213 PROPERTY_GET_SYSTEMINFO_DEFINITION(Battery) {
1214 BatteryPropertiesPtr BatteryPtr(new BatteryProperties());
1218 if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &value) != 0) {
1219 return JSValueMakeNull(context);
1221 BatteryPtr->level = (double)(value)/CPU_POWER_DEVICE_VALUE;
1224 if (vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &value2) != 0) {
1225 return JSValueMakeNull(context);
1227 BatteryPtr->isCharging = (value2 == 0) ? false : true;
1230 return JSBatteryInfo::createJSObject(context, BatteryPtr);
1233 PROPERTY_GET_SYSTEMINFO_DEFINITION(Cpu) {
1234 Converter converter(context);
1236 CpuPropertiesPtr cpuPtr(new CpuProperties());
1238 long long usr = 0, nice = 0, system = 0, idle = 0, total = 0, cpuUsage = 0;
1240 fp = fopen("/proc/stat", "r");
1242 return JSValueMakeNull(context);
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);
1255 return JSCpuInfo::createJSObject(context, cpuPtr);
1258 PROPERTY_GET_SYSTEMINFO_DEFINITION(Storage) {
1259 Converter converter(context);
1263 if (statfs(STORAGE_INTERNAL_PATH, &fs) < 0) {
1264 return JSValueMakeNull(context);
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);
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);
1288 return JSStorageInfo::createJSObject(context, storagePtr);
1292 PROPERTY_GET_SYSTEMINFO_DEFINITION(Display) {
1293 Converter converter(context);
1295 DisplayPropertiesPtr display(new DisplayProperties());
1296 int brightness=0, dotsPerInch=0, physicalW=0, physicalH=0;
1297 bool screenSizeSmall = false, screenSizeBig = false;
1299 if(vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &brightness) == 0) {
1300 display->brightness = (double)(brightness)/DISPLAY_BRIGHTNESS_DIVIDE_VALUE;
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;
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;
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;
1322 if(system_info_get_value_int(SYSTEM_INFO_KEY_PHYSICAL_SCREEN_WIDTH, &physicalW) == SYSTEM_INFO_ERROR_NONE) {
1323 display->physicalWidth = physicalW;
1326 if(system_info_get_value_int(SYSTEM_INFO_KEY_PHYSICAL_SCREEN_HEIGHT, &physicalH) == SYSTEM_INFO_ERROR_NONE) {
1327 display->physicalHeight = physicalH;
1330 return JSDisplayInfo::createJSObject(context, display);
1333 PROPERTY_GET_SYSTEMINFO_DEFINITION(Network) {
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;
1341 if (connection_get_type(connectionHandle, &connectionType) != CONNECTION_ERROR_NONE) {
1342 LoggerD("get connection type is failed");
1343 return JSNetworkInfo::createJSObject(context, Network);
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";
1362 Network->networkType= "NONE";
1366 Network->networkType= "NONE";
1369 return JSNetworkInfo::createJSObject(context, Network);
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;
1383 if (connection_get_type(connectionHandle, &connectionType) != CONNECTION_ERROR_NONE) {
1384 return JSWifiNetworkInfo::createJSObject(context, wifiNetwork);
1387 if (connectionType == CONNECTION_TYPE_WIFI) {
1388 wifiNetwork->status = "ON";
1390 wifiNetwork->status = "OFF";
1391 return JSWifiNetworkInfo::createJSObject(context, wifiNetwork);
1394 if (connection_get_current_profile(connectionHandle, &profileHandle) != CONNECTION_ERROR_NONE) {
1395 return JSWifiNetworkInfo::createJSObject(context, wifiNetwork);
1398 if (connection_profile_get_wifi_essid(profileHandle, &essid) == CONNECTION_ERROR_NONE) {
1399 wifiNetwork->ssid = essid;
1403 if (connection_profile_get_ip_address(profileHandle, addressFamily, &ipAddr) == CONNECTION_ERROR_NONE) {
1404 wifiNetwork->ipAddress = ipAddr;
1408 if (connection_profile_get_wifi_rssi(profileHandle, &rssi) == CONNECTION_ERROR_NONE) {
1409 wifiNetwork->signalStrength = (double) rssi/WIFI_SIGNAL_STRENGTH_DIVIDE_VALUE;
1412 return JSWifiNetworkInfo::createJSObject(context, wifiNetwork);
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;
1425 int plmn = 0, cellId = 0, lac = 0, isRoaming = 0, isFlightMode = 0;
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;
1432 TIME_TRACER_ITEM_END("(cellular)mcc", 0);
1434 TIME_TRACER_ITEM_BEGIN("(cellular)cellId", 0);
1435 if (vconf_get_int(VCONFKEY_TELEPHONY_CELLID, &cellId) == 0) {
1436 cellularNetwork->cellId = cellId;
1438 TIME_TRACER_ITEM_END("(cellular)cellId", 0);
1440 TIME_TRACER_ITEM_BEGIN("(cellular)lac", 0);
1441 if (vconf_get_int(VCONFKEY_TELEPHONY_LAC, &lac) == 0) {
1442 cellularNetwork->lac = lac;
1444 TIME_TRACER_ITEM_END("(cellular)lac", 0);
1446 TIME_TRACER_ITEM_BEGIN("(cellular)isRoaming", 0);
1447 if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ROAM, &isRoaming) == 0) {
1449 cellularNetwork->isRoaming = true;
1451 cellularNetwork->isRoaming = false;
1454 TIME_TRACER_ITEM_END("(cellular)isRoaming", 0);
1456 TIME_TRACER_ITEM_BEGIN("(cellular)isFlightMode", 0);
1457 if (vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &isFlightMode) == 0) {
1459 cellularNetwork->isFlightMode = true;
1461 cellularNetwork->isFlightMode = false;
1464 TIME_TRACER_ITEM_END("(cellular)isFlightMode", 0);
1466 if (connection_get_type(connectionHandle, &connectionType) != CONNECTION_ERROR_NONE) {
1467 return JSCellularNetworkInfo::createJSObject(context, cellularNetwork);
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;
1478 TIME_TRACER_ITEM_END("(cellular)apn", 0);
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;
1485 TIME_TRACER_ITEM_END("(cellular)ipAddress", 0);
1486 connection_profile_destroy(profileHandle);
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;
1496 TIME_TRACER_ITEM_END("(cellular)apn", 0);
1497 connection_profile_destroy(profileHandle);
1501 imei = tel_get_misc_me_imei_sync((TapiHandle*)tapiHandle);
1504 LoggerD("imei : " << imei);
1505 cellularNetwork->imei = imei;
1508 LoggerD("get fail imei");
1511 return JSCellularNetworkInfo::createJSObject(context, cellularNetwork);
1514 PROPERTY_GET_SYSTEMINFO_DEFINITION(SIM) {
1515 Converter converter(context);
1516 SIMPropertiesPtr SIM(new SIMProperties());
1518 return JSSIMInfo::createJSObject(context, SIM);
1521 PROPERTY_GET_SYSTEMINFO_DEFINITION(DeviceOrientation) {
1523 Converter converter(context);
1524 DeviceOrientationPropertiesPtr deviceOrientation(new DeviceOrientationProperties());
1526 unsigned long rotation = 0;
1527 int handleOrientaion = 0;
1528 int isAutoRotation = 0;
1530 if (vconf_get_bool(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, &isAutoRotation) == 0) {
1531 if (isAutoRotation) {
1532 deviceOrientation->isAutoRotation = true;
1534 deviceOrientation->isAutoRotation = false;
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);
1544 int state = sf_start(handleOrientaion, 0);
1546 LoggerD("start failed");
1549 int ret_val = sf_check_rotation(&rotation);
1551 LoggerD("sf_check_rotation fail to gather data\n");
1554 LoggerD(" rotation value = " << rotation);
1558 case ROTATION_EVENT_0:
1559 LoggerD("my_callback_func received data (PORTRAIT_TOP|HEAD_CENTER)\n");
1560 deviceOrientation->status = "PORTRAIT_PRIMARY";
1562 case ROTATION_EVENT_90:
1563 LoggerD("my_callback_func received data (LANDSCAPE|HEAD_RIGHT)\n");
1564 deviceOrientation->status = "LANDSCAPE_PRIMARY";
1566 case ROTATION_EVENT_180:
1567 LoggerD("my_callback_func received data (PORTRAIT_BTM|HEAD_CENTER)\n");
1568 deviceOrientation->status = "PORTRAIT_SECONDARY";
1570 case ROTATION_EVENT_270:
1571 LoggerD("my_callback_func received data (LANDSCAPE|HEAD_LEFT)\n");
1572 deviceOrientation->status = "LANDSCAPE_SECONDARY";
1575 LoggerD(" received data unexpected\n");
1579 state = sf_stop(handleOrientaion);
1580 LoggerD("handleOrientaion 1 state = " << state);
1582 state = sf_disconnect(handleOrientaion);
1583 LoggerD("handleOrientaion state =" << state);
1585 return JSDeviceOrientationInfo::createJSObject(context, deviceOrientation);
1588 PROPERTY_GET_SYSTEMINFO_DEFINITION(Build) {
1590 Converter converter(context);
1591 BuildPropertiesPtr Build(new BuildProperties());
1594 char* manufacturer = NULL;
1595 char* buildVersion = NULL;
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;
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;
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;
1621 return JSBuildInfo::createJSObject(context, Build);
1624 PROPERTY_GET_SYSTEMINFO_DEFINITION(Locale) {
1626 Converter converter(context);
1627 LocalePropertiesPtr Locale(new LocaleProperties());
1629 char* country = NULL;
1630 char* language = NULL;
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;
1640 if (runtime_info_get_value_string(RUNTIME_INFO_KEY_REGION, &country) == RUNTIME_INFO_ERROR_NONE) {
1641 if (country != NULL) {
1642 LoggerD("country : " << country);
1644 char* countryTemp = NULL;
1645 token = strtok(country, ".");
1646 if (token != NULL) {
1647 countryTemp = strdup(token);
1648 if (countryTemp != NULL) {
1649 Locale->country = countryTemp;
1657 return JSLocaleInfo::createJSObject(context, Locale);
1660 PROPERTY_GET_SYSTEMINFO_DEFINITION(Peripheral) {
1661 Converter converter(context);
1662 PeripheralPropertiesPtr peripheral(new PeripheralProperties());
1663 int hdmiStatus = 0, wirelessDisplayStatus = 0 ;
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;
1671 LoggerD("VideOutput status is off");
1676 if (vconf_get_int(VCONFKEY_SYSMAN_HDMI, &hdmiStatus) == 0) {
1677 switch(hdmiStatus) {
1678 case VCONFKEY_SYSMAN_HDMI_CONNECTED:
1679 peripheral->isVideoOutputOn = true;
1682 LoggerD("VideOutput status is off");
1687 return JSPeripheralInfo::createJSObject(context, peripheral);