void change_mode_cb(keynode_t* in_key, void *data) { __USB_FUNC_ENTER__ ; if(!data) return ; UmMainData *ad = (UmMainData *)data; int ret = -1; int usbSelMode = -1; int usbCurMode = -1; if (VCONFKEY_SYSMAN_USB_AVAILABLE != check_usb_connection()) { return ; } ret = vconf_get_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, &usbSelMode); um_retm_if (0 != ret , "ERROR: Cannot get the vconf key\n"); ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usbCurMode); um_retm_if (0 != ret , "ERROR: Cannot get the vconf key\n"); um_retm_if (usbSelMode == usbCurMode, "Previous connection mode is same as the input mode\n"); ret = set_USB_mode(ad, usbSelMode); um_retm_if (0 != ret, "ERROR: Cannot set USB mode \n"); __USB_FUNC_EXIT__ ; return ; }
int set_USB_mode(UmMainData *ad, int mode) { __USB_FUNC_ENTER__ ; if(!ad) return -1; int ret = -1; int done = ACT_FAIL; int usbCurMode = -1; ret = vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE, IN_MODE_CHANGE); if (0 != ret) { USB_LOG("FAIL: vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE)"); } ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usbCurMode); if (0 == ret && SETTING_USB_NONE_MODE != usbCurMode) { action_clean(ad, usbCurMode); } USB_LOG("Mode change : %d\n", mode); done = run_core_action(ad, mode); ret = usb_mode_change_done(ad, done); um_retvm_if(0 != ret, -1, "usb_mode_change_done(ad, done)"); ret = vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE, CHANGE_COMPLETE); if (0 != ret) { USB_LOG("vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE)"); } __USB_FUNC_EXIT__ ; return 0; }
static void indicator_mmc_change_cb(keynode_t *node, void *data) { int status = 0; int ret; retif(data == NULL, , "Invalid parameter!"); ret = vconf_get_int(VCONFKEY_FILEMANAGER_DB_STATUS, &status); if (ret == FAIL) { ERR("Failed to get VCONFKEY_MMC_STATE!"); return; } switch (status) { case VCONFKEY_FILEMANAGER_DB_UPDATING: INFO("MMC loading"); mmc.img_obj.data = icon_path[0]; indicator_util_icon_show(&mmc); indicator_util_icon_animation_set(&mmc, ICON_ANI_BLINK); break; case VCONFKEY_FILEMANAGER_DB_UPDATED: default: indicator_util_icon_hide(&mmc); break; } }
static void _lockd_notify_lock_state_cb(keynode_t * node, void *data) { LOCKD_DBG("lock state changed!!"); struct lockd_data *lockd = (struct lockd_data *)data; int val = -1; if (lockd == NULL) { LOCKD_ERR("lockd is NULL"); return; } if (vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &val) < 0) { LOCKD_ERR("Cannot get VCONFKEY_IDLE_LOCK_STATE"); return; } if (val == VCONFKEY_IDLE_UNLOCK) { LOCKD_DBG("unlocked..!!"); if (lockd->lock_app_pid != 0) { LOCKD_DBG("terminate lock app..!!"); lockd_process_mgr_terminate_lock_app(lockd->lock_app_pid, 1); } } }
int action_clean(UmMainData *ad, int mode) { __USB_FUNC_ENTER__ ; if(!ad) return -1; int ret = -1; int usbSelMode = -1; ret = vconf_get_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, &usbSelMode); switch(mode) { case SETTING_USB_DEFAULT_MODE: USB_LOG("Mode : SETTING_USB_DEFAULT_MODE action_clean\n"); call_cmd(SDBD_STOP); break; case SETTING_USB_DEBUG_MODE: call_cmd(OPENSSHD_STOP); if (SETTING_USB_MOBILE_HOTSPOT == usbSelMode) { call_cmd(OPENSSHD_STOP); } break; case SETTING_USB_MOBILE_HOTSPOT: USB_LOG("Mode : SETTING_USB_MOBILE_HOTSPOT action_clean\n"); if (SETTING_USB_DEBUG_MODE == usbSelMode) { call_cmd(UNSET_USB0_IP); } break; case SETTING_USB_ACCESSORY_MODE: default: break; } ret = mode_set_kernel(ad->driverVersion, SETTING_USB_NONE_MODE); um_retvm_if(0 != ret, -1, "FAIL: mode_set_kernel(SETTING_USB_SAMSUNG_KIES)"); __USB_FUNC_EXIT__ ; return 0; }
static void lockd_launch_lockscreen(struct lockd_data *lockd) { LOCKD_DBG("launch lock screen"); int call_state = -1; int r = 0; if (lockd_process_mgr_check_lock(lockd->lock_app_pid) == TRUE) { LOCKD_DBG("Lock Screen App is already running."); r = lockd_process_mgr_restart_lock(); if (r < 0) { LOCKD_DBG("Restarting Lock Screen App is fail [%d].", r); } else { LOCKD_DBG("Restarting Lock Screen App, pid[%d].", r); return; } } vconf_get_int(VCONFKEY_CALL_STATE, &call_state); if (call_state != VCONFKEY_CALL_OFF) { LOCKD_DBG ("Current call state(%d) does not allow to launch lock screen.", call_state); return; } lockd_window_mgr_ready_lock(lockd, lockd->lockw, lockd_app_create_cb, lockd_app_show_cb); lockd->lock_app_pid = lockd_process_mgr_start_lock(lockd, lockd_app_dead_cb); vconf_set_int(VCONFKEY_IDLE_LOCK_STATE, VCONFKEY_IDLE_LOCK); }
int connectUsb(UmMainData *ad) { __USB_FUNC_ENTER__ ; if(!ad) return -1; int ret = -1; int mh_status = -1; int usbSelMode = -1; /* If the mobile hotspot is on, USB-setting changes USB mode to mobile hotspot */ mh_status = check_mobile_hotspot_status(); if ((mh_status >= 0) && (mh_status & VCONFKEY_MOBILE_HOTSPOT_MODE_USB)) { USB_LOG("Mobile hotspot is on\n"); ret = vconf_set_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, SETTING_USB_MOBILE_HOTSPOT); um_retvm_if (0 != ret, -1, "FAIL: vconf_set_int(VCONF_SETAPPL_USB_SEL_MODE_INT)\n"); __USB_FUNC_EXIT__ ; return 0; } else { USB_LOG("Mobile hotspot is off\n"); } ret = vconf_get_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, &usbSelMode); if (0 != ret) { USB_LOG("FAIL: vconf_get_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT)\n"); usbSelMode = SETTING_USB_DEFAULT_MODE; } ret = set_USB_mode(ad, usbSelMode); if (0 != ret) { USB_LOG("ERROR: Cannot set USB mode \n"); } __USB_FUNC_EXIT__ ; return 0; }
int disconnectUsb(UmMainData *ad) { __USB_FUNC_ENTER__ ; if(!ad) return -1; int ret = -1; int usbCurMode = -1; ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usbCurMode); um_retvm_if(ret <0, -1, "FAIL: vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT)\n"); action_clean(ad, usbCurMode); ret = vconf_set_int(VCONFKEY_SETAPPL_USB_MODE_INT, SETTING_USB_NONE_MODE); if (ret != 0) { USB_LOG("ERROR: vconf_set_int(VCONFKEY_SETAPPL_USB_MODE_INT)\n"); } ret = vconf_set_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, SETTING_USB_DEFAULT_MODE); if (0 != ret) { USB_LOG("ERROR: vconf_set_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT)\n"); } ret = vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE, CHANGE_COMPLETE); if (0 != ret) { USB_LOG("FAIL: vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE)\n"); } __USB_FUNC_EXIT__ ; return 0; }
int usb_mode_change_done(UmMainData *ad, int done) { __USB_FUNC_ENTER__ ; if(!ad) return -1; int vconf_ret = -1; int ret = -1; int usbSelMode = -1; int usbCurMode = -1; if (VCONFKEY_SYSMAN_USB_AVAILABLE != check_usb_connection()) { return 0; } ret = vconf_get_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, &usbSelMode); um_retvm_if(ret < 0, -1, "FAIL: vconf_get_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT)\n"); ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usbCurMode); um_retvm_if(ret < 0, -1, "FAIL: vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT)\n"); if(ACT_SUCCESS == done) { /* Decide current mode */ switch (usbSelMode) { case SETTING_USB_MOBILE_HOTSPOT: if (usbCurMode != SETTING_USB_NONE_MODE) { ad->usbSelMode = usbCurMode; break; } case SETTING_USB_DEFAULT_MODE: case SETTING_USB_DEBUG_MODE: case SETTING_USB_ACCESSORY_MODE: default: ad->usbSelMode = SETTING_USB_DEFAULT_MODE; break; } usbCurMode = usbSelMode; vconf_ret = vconf_set_int(VCONFKEY_SETAPPL_USB_MODE_INT, usbCurMode); um_retvm_if (0 != vconf_ret, -1, "FAIL: vconf_set_int(VCONFKEY_SETAPPL_USB_MODE_INT)\n"); if (SETTING_USB_MOBILE_HOTSPOT != usbCurMode) { load_connection_popup(ad); } } else { /* USB mode change failed */ action_clean(ad, usbSelMode); load_system_popup(ad, ERROR_POPUP); } __USB_FUNC_EXIT__ ; return 0; }
int _get_usb_state(int *usb_state) { if (-1 == vconf_get_int(VCONFKEY_SYSMAN_USB_STATUS, (void *)usb_state)) { ERR("Vconf get failed\n"); return -1; } DBG("USB state : %d\n", *usb_state); return 0; }
static void netconfig_wifi_statistics_update_state( enum netconfig_wifi_service_state state, void *user_data) { guint64 tx = 0, rx = 0; guint64 last_tx = 0, last_rx = 0; int val = 0; static enum netconfig_wifi_service_state prev_state = NETCONFIG_WIFI_UNKNOWN; if (prev_state == NETCONFIG_WIFI_UNKNOWN) { vconf_set_int(VCONFKEY_NETWORK_WIFI_PKT_LAST_SNT, 0); vconf_set_int(VCONFKEY_NETWORK_WIFI_PKT_LAST_RCV, 0); prev_state = NETCONFIG_WIFI_IDLE; return; } if (__netconfig_wifi_get_bytes_statistics(&tx, &rx) != TRUE) return; if (state == NETCONFIG_WIFI_CONNECTED) { last_tx = tx; last_rx = rx; } else { if (prev_state != NETCONFIG_WIFI_CONNECTED) return; vconf_get_int(VCONFKEY_NETWORK_WIFI_PKT_LAST_SNT, &val); last_tx = (guint64)val; vconf_get_int(VCONFKEY_NETWORK_WIFI_PKT_LAST_RCV, &val); last_rx = (guint64)val; last_tx = (((guint64)tx - (guint64)last_tx) > (guint64)0) ? ((guint64)tx - (guint64)last_tx) : (guint64)0; last_rx = (((guint64)rx - (guint64)last_rx) > (guint64)0) ? ((guint64)rx - (guint64)last_rx) : (guint64)0; } vconf_set_int(VCONFKEY_NETWORK_WIFI_PKT_LAST_SNT, (int)last_tx); vconf_set_int(VCONFKEY_NETWORK_WIFI_PKT_LAST_RCV, (int)last_rx); prev_state = state; }
static int check_mobile_hotspot_status() { __USB_FUNC_ENTER__ ; int mh_status = -1; int ret = -1; ret = vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &mh_status); um_retvm_if (0 != ret, -1, "FAIL: vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE)\n"); __USB_FUNC_EXIT__ ; return mh_status; }
void netconfig_wifi_statistics_update_powered_off(void) { guint64 cur_tx = 0, cur_rx = 0; guint64 prev_tx = 0, prev_rx = 0; guint64 total_tx = 0, total_rx = 0; int val = 0; if (__netconfig_wifi_get_bytes_statistics(&cur_tx, &cur_rx) != TRUE) return; vconf_get_int(VCONFKEY_NETWORK_WIFI_PKT_TOTAL_SNT, &val); prev_tx = (guint64)val; vconf_get_int(VCONFKEY_NETWORK_WIFI_PKT_TOTAL_RCV, &val); prev_rx = (guint64)val; total_tx = prev_tx + cur_tx; total_rx = prev_rx + cur_rx; vconf_set_int(VCONFKEY_NETWORK_WIFI_PKT_TOTAL_SNT, (int)total_tx); vconf_set_int(VCONFKEY_NETWORK_WIFI_PKT_TOTAL_RCV, (int)total_rx); }
static int run_core_action(UmMainData *ad, int mode) { __USB_FUNC_ENTER__ ; if(!ad) return ACT_FAIL; int ret = -1; int usbCurMode = -1; ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usbCurMode); um_retvm_if(0 != ret, ACT_FAIL, "FAIL: vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT)\n"); switch(mode) { case SETTING_USB_DEFAULT_MODE: USB_LOG("Mode : SETTING_USB_DFAULT_MODE\n"); ret = mode_set_kernel(ad->driverVersion, SETTING_USB_DEFAULT_MODE); um_retvm_if(0 != ret, ACT_FAIL, "FAIL : mode_set_kernel()\n"); start_dr(ad); call_cmd(SDBD_START); break; case SETTING_USB_DEBUG_MODE: USB_LOG("Mode: SETTING_USB_DEBUG_MODE\n"); if (SETTING_USB_MOBILE_HOTSPOT != usbCurMode) { ret = mode_set_kernel(ad->driverVersion, SETTING_USB_DEBUG_MODE); um_retvm_if(0 != ret, ACT_FAIL, "FAIL : mode_set_kernel()\n"); call_cmd(SET_USB0_IP); call_cmd(ADD_DEFAULT_GW); } call_cmd(OPENSSHD_START); case SETTING_USB_MOBILE_HOTSPOT: USB_LOG("Mode : SETTING_USB_MOBILE_HOTSPOT\n"); if (SETTING_USB_DEBUG_MODE != usbCurMode) { ret = mode_set_kernel(ad->driverVersion, SETTING_USB_DEBUG_MODE); um_retvm_if(0 != ret, ACT_FAIL, "FAIL : mode_set_kernel()\n"); call_cmd(SET_USB0_IP); call_cmd(ADD_DEFAULT_GW); } break; case SETTING_USB_ACCESSORY_MODE: USB_LOG("Mode : SETTING_USB_ACCESSORY_MODE\n"); ret = mode_set_kernel(ad->driverVersion, SETTING_USB_ACCESSORY_MODE); um_retvm_if(0 != ret, ACT_FAIL, "FAIL : mode_set_kernel()\n"); break; default: break; } __USB_FUNC_EXIT__ ; return ACT_SUCCESS; }
gboolean _bt_get_default_storage(char *storage) { int val = -1; if (-1 == vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT, (void *)&val)) { DBG("vconf error\n"); return FALSE; } if (val == 0) /* Phone memory is 0, MMC is 1 */ g_strlcpy(storage, BT_DOWNLOAD_PHONE_FOLDER, STORAGE_PATH_LEN_MAX); else g_strlcpy(storage, BT_DOWNLOAD_MMC_FOLDER, STORAGE_PATH_LEN_MAX); DBG("Default storage : %s\n", storage); return TRUE; }
gboolean netconfig_iface_network_statistics_get_wifi_total_rx_bytes(NetconfigNetworkStatistics *network_statistics, guint64 *total_bytes, GError **error) { guint64 tx = 0, rx = 0; guint64 rx_bytes = 0; int val = 0; vconf_get_int(VCONFKEY_NETWORK_WIFI_PKT_TOTAL_RCV, &val); rx_bytes = (guint64)val; if (__netconfig_wifi_get_bytes_statistics(&tx, &rx) == TRUE) *total_bytes = (guint64)rx + (guint64)rx_bytes; else *total_bytes = (guint64)rx_bytes; return TRUE; }
static void indicator_battery_check_charging(void *data) { int ret = -1; int status = 0; ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &status); if (ret != OK) ERR("Fail to get [VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW:%d]", ret); INFO("Battery charge Status: %d", status); if (battery_charging != !(!status)) { battery_charging = !(!status); indicator_bttery_update_by_charging_state(data); } }
static void indicator_fm_radio_change_cb(keynode_t *node, void *data) { int status; int ret; retif(data == NULL, , "Invalid parameter!"); ret = vconf_get_int(VCONFKEY_RADIO_STATE, &status); if (ret == OK) { INFO("FM_RADIO state: %d", status); if (status == VCONFKEY_RADIO_PLAY) show_image_icon(data); else hide_image_icon(); } return; }
EXPORT_API int appcore_get_timeformat(enum appcore_time_format *timeformat) { int r; if (timeformat == NULL) { errno = EINVAL; return -1; } r = vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224, (int *)timeformat); if (r < 0) { *timeformat = APPCORE_TIME_FORMAT_UNKNOWN; return -1; } else return 0; }
int MsgSettingGetInt(const char *pKey) { if (pKey == NULL) { MSG_DEBUG("IN Parameter is NULL"); return -1; } int retVal = 0; #ifdef USE_GCONF retVal = gconf_client_get_int((GConfClient*)pClient, pKey, NULL); #else if (vconf_get_int(pKey, &retVal) < 0) return -1; #endif return retVal; }
void change_hotspot_status_cb(keynode_t* in_key, void *data) { __USB_FUNC_ENTER__ ; if(!data) return ; UmMainData *ad = (UmMainData *)data; int mh_status = -1; int ret = -1; int usbCurMode = -1; if (VCONFKEY_SYSMAN_USB_AVAILABLE != check_usb_connection()) { return; } mh_status = check_mobile_hotspot_status(); USB_LOG("mobile_hotspot_status: %d\n", mh_status); um_retm_if (0 > mh_status, "FAIL: Getting mobile hotspot status\n"); ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usbCurMode); um_retm_if (0 != ret, "FAIL: vconf_get_int(VCONF_SETAPPL_USB_MODE_INT)\n"); if (mh_status & VCONFKEY_MOBILE_HOTSPOT_MODE_USB) { USB_LOG("USB Mobile hotspot is on\n"); if (usbCurMode != SETTING_USB_MOBILE_HOTSPOT) { /* When mobile hotspot is on, this callabck only sets vconf key value of USB mode. * And then, the callback function for vconf change will be called */ ret = vconf_set_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, SETTING_USB_MOBILE_HOTSPOT); um_retm_if (0 != ret, "FAIL: vconf_set_int(VCONF_SETAPPL_USB_MODE_INT)\n"); } } else { USB_LOG("USB Mobile hotspot is off\n"); if (usbCurMode == SETTING_USB_MOBILE_HOTSPOT) { ret = vconf_set_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, ad->usbSelMode); if (0 != ret) { USB_LOG("FAIL: vconf_set_int(VCONF_SETAPPL_USB_SEL_MODE_INT)\n"); return; } } } __USB_FUNC_EXIT__ ; }
static void _lockd_notify_pm_state_cb(keynode_t * node, void *data) { LOCKD_DBG("PM state Notification!!"); struct lockd_data *lockd = (struct lockd_data *)data; int val = -1; if (lockd == NULL) { LOCKD_ERR("lockd is NULL"); return; } if (vconf_get_int(VCONFKEY_PM_STATE, &val) < 0) { LOCKD_ERR("Cannot get VCONFKEY_PM_STATE"); return; } if (val == VCONFKEY_PM_STATE_LCDOFF) { lockd_launch_app_lockscreen(lockd); } }
void get_operation(int i, const char* parent_dir) { keylist_t *kl=NULL; keynode_t *temp_node; int get_int; double get_dbl; char *get_str; vconf_get_dbl(vconfkeys[i][0], &get_dbl); vconf_get_bool(vconfkeys[i][1], &get_int); get_str=vconf_get_str(vconfkeys[i][2]); free(get_str); vconf_get_int(vconfkeys[i][3], &get_int); kl = vconf_keylist_new(); vconf_get(kl, parent_dir, 0); while((temp_node = vconf_keylist_nextnode(kl))) { switch(vconf_keynode_get_type(temp_node)) { case VCONF_TYPE_INT: printf("key = %s, value = %d\n", vconf_keynode_get_name(temp_node), vconf_keynode_get_int(temp_node)); break; case VCONF_TYPE_BOOL: printf("key = %s, value = %d\n", vconf_keynode_get_name(temp_node), vconf_keynode_get_bool(temp_node)); break; case VCONF_TYPE_DOUBLE: printf("key = %s, value = %f\n", vconf_keynode_get_name(temp_node), vconf_keynode_get_dbl(temp_node)); break; case VCONF_TYPE_STRING: printf("key = %s, value = %s\n", vconf_keynode_get_name(temp_node), vconf_keynode_get_str(temp_node)); break; default: printf("Unknown Type\n"); } } vconf_keylist_free(kl); }
static gboolean __bt_get_available_memory(long *available_mem_size) { struct statfs fs = {0, }; int val = -1; char *default_memory = NULL; if (-1 == vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT, (void *)&val)) { ERR("vconf error\n"); return FALSE; } if (val == 0) /* Phone memory is 0, MMC is 1 */ default_memory = BT_DOWNLOAD_MEDIA_FOLDER; else default_memory = BT_DOWNLOAD_MMC_FOLDER; if (statfs(default_memory, &fs) != 0) { *available_mem_size = 0; return FALSE; } *available_mem_size = fs.f_bavail * (fs.f_bsize/1024); return TRUE; }
static void indicator_battery_update_display(void *data) { int battery_capa = 0; int ret; int level = 0; retif(data == NULL, , "Invalid parameter!"); ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &battery_capa); if (ret != OK) ERR("Fail to get [VCONFKEY_SYSMAN_BATTERY_CAPACITY:%d]", ret); INFO("Battery Capacity: %d", battery_capa); if (battery_capa < 0) battery_capa = 0; else if (battery_capa > 100) battery_capa = 100; if (battery_capa == _level.current_capa) { DBG("battery capacity is not changed"); return; } _level.current_capa = battery_capa; /* Check Percentage option */ if (battery_percentage_on == EINA_TRUE) { indicator_battery_text_set(data, _level.current_capa); show_battery_icon(); } /* Check Battery Level */ level = __battery_capa_to_level(battery_capa); if (level == _level.current_level) DBG("battery level is not changed"); else { _level.current_level = level; indicator_bttery_update_by_charging_state(data); } }
gboolean netconfig_iface_network_statistics_get_wifi_last_rx_bytes(NetconfigNetworkStatistics *network_statistics, guint64 *last_bytes, GError **error) { guint64 tx = 0, rx = 0; guint64 rx_bytes = 0; int val = 0; vconf_get_int(VCONFKEY_NETWORK_WIFI_PKT_LAST_RCV, &val); rx_bytes = (guint64)val; if (netconfig_wifi_state_get_service_state() != NETCONFIG_WIFI_CONNECTED) { *last_bytes = (guint64)rx_bytes; return TRUE; } if (__netconfig_wifi_get_bytes_statistics(&tx, &rx) == TRUE) *last_bytes = (((guint64)rx - (guint64)rx_bytes) > (guint64)0) ? ((guint64)rx - (guint64)rx_bytes) : (guint64)0; else *last_bytes = (guint64)rx_bytes; return TRUE; }
int rua_add_history(struct rua_rec *rec) { int r; int cnt = 0; char query[QUERY_MAXLEN]; sqlite3_stmt *stmt; unsigned int timestamp; timestamp = PERF_MEASURE_START("RUA"); LOGD("rua_add_history invoked"); if (_db == NULL) { LOGE("rua is not inited."); return -1; } if (rec == NULL) { LOGE("rec is null"); return -1; } snprintf(query, QUERY_MAXLEN, "select count(*) from %s where pkg_name = '%s';", RUA_HISTORY, rec->pkg_name); r = sqlite3_prepare(_db, query, sizeof(query), &stmt, NULL); if (r != SQLITE_OK) { LOGE("query prepare error(%d)", r); return -1; } r = sqlite3_step(stmt); if (r == SQLITE_ROW) { cnt = sqlite3_column_int(stmt, 0); } sqlite3_finalize(stmt); /****************************************************/ if (!flag) { vconf_unset_recursive ("db/rua_data"); flag = 1; } if(strcmp(rec->pkg_name, "org.tizen.menu-screen") && strcmp(rec->pkg_name, "org.tizen.volume") && strcmp(rec->pkg_name, "org.tizen.lockscreen") && strcmp(rec->pkg_name, "org.tizen.pwlock")){ int total = 0; int apps; char key[255], *key2 = "db/rua_data/apps"; sprintf (key, "db/rua_data/%s", "tizen_total_cnt"); if (vconf_get_int (key, &total) < 0) total = 0; vconf_set_int (key, total + 1); memset (key, 0, 255); sprintf (key, "db/rua_data/%s", rec->pkg_name); if (vconf_get_int (key, &total) < 0) { total = 0; if (vconf_get_int (key2, &apps) < 0) apps = 0; vconf_set_int (key2, apps + 1); } vconf_set_int (key, total + 1); } /****************************************************/ if (cnt == 0) { /* insert */ snprintf(query, QUERY_MAXLEN, "insert into %s ( pkg_name, app_path, arg, launch_time ) " " values ( \"%s\", \"%s\", \"%s\", %d ) ", RUA_HISTORY, rec->pkg_name ? rec->pkg_name : "", rec->app_path ? rec->app_path : "", rec->arg ? rec->arg : "", (int)time(NULL)); } else { /* update */ snprintf(query, QUERY_MAXLEN, "update %s set arg='%s', launch_time='%d' where pkg_name = '%s';", RUA_HISTORY, rec->arg ? rec->arg : "", (int)time(NULL), rec->pkg_name); } r = __exec(_db, query); if (r == -1) { LOGE("[RUA ADD HISTORY ERROR] %s\n", query); return -1; } PERF_MEASURE_END("RUA", timestamp); return r; }