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;
}
