From 86a6eff6e55bdb2ba8be35166a9e4ad0c58c2370 Mon Sep 17 00:00:00 2001 From: "hyunuk.tak" Date: Wed, 14 Aug 2019 17:36:46 +0900 Subject: [PATCH] Add battery monitor framework Change-Id: Iaccffa57e6ce5d0fb8ce8112452c6893fcd232f8 Signed-off-by: hyunuk.tak --- CMakeLists.txt | 2 + include/netdbus.h | 1 + include/plugin.h | 96 ++++ include/util.h | 10 + interfaces/netconfig-iface-network-state.xml | 8 + packaging/net-config.spec | 23 +- plugin/battery/CMakeLists.txt | 41 ++ plugin/battery/battery.c | 550 +++++++++++++++++++ plugin/stc/CMakeLists.txt | 42 ++ plugin/stc/stc.c | 218 ++++++++ src/network-state.c | 59 ++ src/signal-handler.c | 134 ++++- src/utils/util.c | 167 ++++++ src/wifi-indicator.c | 2 + src/wifi-state.c | 2 + 15 files changed, 1350 insertions(+), 5 deletions(-) create mode 100755 plugin/battery/CMakeLists.txt create mode 100755 plugin/battery/battery.c create mode 100755 plugin/stc/CMakeLists.txt create mode 100755 plugin/stc/stc.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 8abfbac..bce51e7 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -133,6 +133,8 @@ INSTALL(FILES ${CMAKE_SOURCE_DIR}/config/security-network-config.conf DESTINATIO ADD_SUBDIRECTORY(plugin/headed) ADD_SUBDIRECTORY(plugin/telephony) +ADD_SUBDIRECTORY(plugin/stc) +ADD_SUBDIRECTORY(plugin/battery) ADD_SUBDIRECTORY(haltests) IF(BUILD_GTESTS) ADD_SUBDIRECTORY(gtest) diff --git a/include/netdbus.h b/include/netdbus.h index 36ec2ce..11fe40c 100755 --- a/include/netdbus.h +++ b/include/netdbus.h @@ -61,6 +61,7 @@ extern "C" { #define NETCONFIG_NETWORK_STATISTICS_PATH "/net/netconfig/network_statistics" #define NETCONFIG_NETWORK_PATH "/net/netconfig/network" #define NETCONFIG_NETWORK_INTERFACE "net.netconfig.network" +#define NETCONFIG_BATTERY_INTERFACE "net.netconfig.battery" #define NETCONFIG_VPNSVC_PATH "/net/netconfig/vpnsvc" #define NETCONFIG_VPNSVC_INTERFACE "net.netconfig.vpnsvc" #define NETCONFIG_MPTCP_PATH "/net/netconfig/mptcp" diff --git a/include/plugin.h b/include/plugin.h index 48cc2b7..8c92136 100755 --- a/include/plugin.h +++ b/include/plugin.h @@ -72,6 +72,102 @@ struct netconfig_telephony_plugin_t { GDBusMethodInvocation *context, struct wifi_authentication_data **data); }; +struct netconfig_stc_plugin_t { + void (*get_stc_dn_stats) (time_t, time_t, GSList **); + void (*get_stc_wifi_stats) (time_t, time_t, GSList **); +}; + +#define BATTERY_ATM_LIST "atm_list" +#define BATTERY_ATM_APP_ID "atm_app_id" +#define BATTERY_ATM_RX "atm_rx" +#define BATTERY_ATM_TX "atm_tx" + +#define BATTERY_DN_TIME_LEVEL_0 "time_level_0" +#define BATTERY_DN_TIME_LEVEL_1 "time_level_1" +#define BATTERY_DN_TIME_LEVEL_2 "time_level_2" +#define BATTERY_DN_TIME_LEVEL_3 "time_level_3" +#define BATTERY_DN_TIME_LEVEL_4 "time_level_4" +#define BATTERY_DN_TIME_LEVEL_5 "time_level_5" +#define BATTERY_DN_TIME_LEVEL_6 "time_level_6" + +#define BATTERY_WIFI_TIME_LEVEL_0 "time_level_0" +#define BATTERY_WIFI_TIME_LEVEL_1 "time_level_1" +#define BATTERY_WIFI_TIME_LEVEL_2 "time_level_2" +#define BATTERY_WIFI_TIME_LEVEL_3 "time_level_3" +#define BATTERY_WIFI_TIME_LEVEL_4 "time_level_4" +#define BATTERY_WIFI_START_TIME "start_time" +#define BATTERY_WIFI_END_TIME "end_time" +#define BATTERY_WIFI_SCAN_TIME "scan_time" + +typedef struct { + char *app_id; + uint time; + uint rx; + uint tx; +} battery_app_data_s; + +typedef struct { + uint time_level_0; + uint time_level_1; + uint time_level_2; + uint time_level_3; + uint time_level_4; + uint time_level_5; + uint time_level_6; + GSList *atm_list; + GSList *data_list; + time_t start_time; + time_t end_time; +} battery_dn_data_s; + +typedef struct { + uint time_level_0; + uint time_level_1; + uint time_level_2; + uint time_level_3; + uint time_level_4; + time_t start_time; + time_t end_time; + uint scan_time; + GSList *atm_list; + GSList *data_list; +} battery_wifi_data_s; + +typedef void (*stc_get_stats_cb) (time_t from, time_t to, GSList **list); + +struct netconfig_battery_plugin_t { + void (*start_dn_data) (void); + void (*end_dn_data) (int, stc_get_stats_cb); + void (*update_dn_rssi) (int); + + void (*start_wifi_data) (void); + void (*end_wifi_data) (int, stc_get_stats_cb); + void (*update_wifi_scan) (int); + void (*update_wifi_rssi) (int); + + void (*get_battery_dn_list) (void *, stc_get_stats_cb); + void (*get_battery_wifi_list) (void *, stc_get_stats_cb); +}; + +typedef void *bm_data_h; +typedef enum { + BM_DATA_TYPE_BLE, + BM_DATA_TYPE_WIFI, + BM_DATA_TYPE_CPU, + BM_DATA_TYPE_DISPLAY, + BM_DATA_TYPE_DEVICE_NETWORK, + BM_DATA_TYPE_GPS_SENSOR, + BM_DATA_TYPE_HRM_SENSOR, + BM_DATA_TYPE_BATTERY, + BM_DATA_TYPE_MAX +} bm_plugin_data_type_e; + +struct netconfig_bm_plugin_t { + int (*init) (void); + int (*deinit) (void); + int (*get_feature_data) (bm_data_h *, bm_plugin_data_type_e); +}; + typedef enum { SYS_EVT_NETWORK_STATUS = 0, SYS_EVT_WIFI_STATE = 1, diff --git a/include/util.h b/include/util.h index 18ad640..631b3b7 100755 --- a/include/util.h +++ b/include/util.h @@ -113,6 +113,16 @@ gboolean __netconfig_wifi_get_aka_authdata(Wifi *wifi, gboolean __netconfig_wifi_get_sim_authdata(Wifi *wifi, GDBusMethodInvocation *context, struct wifi_authentication_data **data); +void netconfig_battery_start_dn(void); +void netconfig_battery_end_dn(void); +void netconfig_battery_update_dn_rssi(int rssi); +void netconfig_battery_start_wifi(void); +void netconfig_battery_end_wifi(void); +void netconfig_battery_update_wifi_scan(int state); +void netconfig_battery_update_wifi_rssi(int rssi); +void netconfig_battery_get_dn_list(void *data); +void netconfig_battery_get_wifi_list(void *data); + void netconfig_plugin_init(); void netconfig_plugin_deinit(); gboolean netconfig_get_headed_plugin_flag(); diff --git a/interfaces/netconfig-iface-network-state.xml b/interfaces/netconfig-iface-network-state.xml index 41b65e0..57f7938 100755 --- a/interfaces/netconfig-iface-network-state.xml +++ b/interfaces/netconfig-iface-network-state.xml @@ -55,4 +55,12 @@ + + + + + + + + diff --git a/packaging/net-config.spec b/packaging/net-config.spec index 32eaacc..0dd7a68 100755 --- a/packaging/net-config.spec +++ b/packaging/net-config.spec @@ -1,6 +1,6 @@ Name: net-config Summary: TIZEN Network Configuration service -Version: 1.1.146 +Version: 1.1.147 Release: 3 Group: System/Network License: Apache-2.0 @@ -65,6 +65,19 @@ Requires: %{name} = %{version}-%{release} %description plugin-telephony TIZEN Network Configuration service extension for telephony FW. +%package plugin-stc +Summary: net-config extension for STC FW +BuildRequires: pkgconfig(capi-network-stc) +Requires: %{name} = %{version}-%{release} +%description plugin-stc +TIZEN Network Configuration service extension for STC FW. + +%package plugin-battery +Summary: net-config extension for battery FW +Requires: %{name} = %{version}-%{release} +%description plugin-battery +TIZEN Network Configuration service extension for battery FW. + %package haltests Summary: net-config extension for HAL test BuildRequires: pkgconfig(gmock) @@ -246,6 +259,14 @@ mv net-config.wearable net-config %manifest net-config.manifest %attr(500,network_fw,network_fw) %{_libdir}/net-config-plugin-telephony.so +%files plugin-stc +%manifest net-config.manifest +%attr(500,network_fw,network_fw) %{_libdir}/net-config-plugin-stc.so + +%files plugin-battery +%manifest net-config.manifest +%attr(500,network_fw,network_fw) %{_libdir}/net-config-plugin-battery.so + %files haltests %manifest net-config.manifest %{_bindir}/*haltests diff --git a/plugin/battery/CMakeLists.txt b/plugin/battery/CMakeLists.txt new file mode 100755 index 0000000..21e6980 --- /dev/null +++ b/plugin/battery/CMakeLists.txt @@ -0,0 +1,41 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(net-config-plugin-battery C) + +IF(TIZEN_WEARABLE) + ADD_DEFINITIONS(-DTIZEN_WEARABLE) +ENDIF(TIZEN_WEARABLE) + +ADD_DEFINITIONS(-DUSE_NETCONFIG_LOG) + +# Set required packages +INCLUDE(FindPkgConfig) +PKG_CHECK_MODULES(pkgs_battery REQUIRED + dlog + vconf + gio-2.0 + gio-unix-2.0 + glib-2.0 + ) + +FOREACH(flag ${pkgs_battery_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include) +# INCLUDE_DIRECTORIES(SRCS include) + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -g -Werror") +SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") +SET(CMAKE_C_FLAGS_RELEASE "-O2") + +SET(SRCS_BATTERY + battery.c + ) + +# library build +ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS_BATTERY}) +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_battery_LDFLAGS}) +SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES PREFIX "" OUTPUT_NAME ${PROJECT_NAME}) + +# install +INSTALL(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${LIBDIR}) diff --git a/plugin/battery/battery.c b/plugin/battery/battery.c new file mode 100755 index 0000000..95ad4c5 --- /dev/null +++ b/plugin/battery/battery.c @@ -0,0 +1,550 @@ +/* + * Network Configuration Module + * + * Copyright (c) 2017 Samsung Electronics Co., Ltd. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include "plugin.h" +#include "util.h" + +#ifdef USE_NETCONFIG_LOG +#include "log.h" +#else +#include + +#define NETCONFIG_TAG "NETCONFIG" +#define __LOG(level, format, arg...) \ + do { \ + SLOG(level, NETCONFIG_TAG, format, ## arg); \ + } while (0) + +#define DBG(format, arg...) __LOG(LOG_DEBUG, format, ## arg) +#define ERR(format, arg...) __LOG(LOG_ERROR, format, ## arg) +#endif + +#define BATTERY_MODE_END 0 +#define BATTERY_MODE_GET 1 + +typedef struct { + time_t time; +} battery_scan_data_s; + +typedef struct { + time_t time; + int rssi; +} battery_rssi_data_s; + +static battery_scan_data_s g_wifi_scan_data = { 0, }; + +static battery_rssi_data_s g_dn_rssi_data = { 0, }; +static battery_rssi_data_s g_wifi_rssi_data = { 0, }; + +static battery_dn_data_s *g_dn_data = NULL; +static battery_wifi_data_s *g_wifi_data = NULL; + +static GSList *g_dn_list = NULL; +static GSList *g_wifi_list = NULL; + +static void __battery_free_app_data(void *data) +{ + battery_app_data_s *app_data = (battery_app_data_s *)data; + + g_free(app_data->app_id); + g_free(app_data); +} + +static void __battery_free_dn_data(void *data) +{ + battery_dn_data_s *dn_data = (battery_dn_data_s *)data; + + g_slist_free_full(dn_data->atm_list, __battery_free_app_data); + g_free(dn_data); +} + +static void __battery_flush_dn_list(void) +{ + g_slist_free_full(g_dn_list, __battery_free_dn_data); + g_dn_list = NULL; +} + +static void __battery_free_wifi_data(void *data) +{ + battery_wifi_data_s *wifi_data = (battery_wifi_data_s *)data; + + g_slist_free_full(wifi_data->atm_list, __battery_free_app_data); + g_free(wifi_data); +} + +static void __battery_flush_wifi_list(void) +{ + g_slist_free_full(g_wifi_list, __battery_free_wifi_data); + g_wifi_list = NULL; +} + +static void __battery_print_dn_list(void) +{ + GSList *list = NULL; + + for (list = g_dn_list; list != NULL; list = list->next) { + battery_dn_data_s *dn_data = (battery_dn_data_s *)list->data; + DBG("[Battery DN] rssi[%d/%d/%d/%d/%d/%d/%d]", + dn_data->time_level_0, dn_data->time_level_1, dn_data->time_level_2, + dn_data->time_level_3, dn_data->time_level_4, dn_data->time_level_5, + dn_data->time_level_6); + } +} + +static void __battery_print_wifi_list(void) +{ + GSList* list = NULL; + + for (list = g_wifi_list; list != NULL; list = list->next) { + battery_wifi_data_s *wifi_data = (battery_wifi_data_s *)list->data; + DBG("[Battery Wi-Fi] start[%ld] end[%ld] scan[%d] rssi[%d/%d/%d/%d/%d]", + wifi_data->start_time, wifi_data->end_time, wifi_data->scan_time, + wifi_data->time_level_0, wifi_data->time_level_1, wifi_data->time_level_2, + wifi_data->time_level_3, wifi_data->time_level_4); + } +} + +static void __battery_get_dn_list(void *data, battery_dn_data_s *dn_data) +{ + GVariantBuilder *builder = (GVariantBuilder *)data; + GVariantBuilder sub_builder; + + g_variant_builder_init(&sub_builder, G_VARIANT_TYPE("a{sv}")); + + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_DN_TIME_LEVEL_0, + g_variant_new_uint32(dn_data->time_level_0)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_DN_TIME_LEVEL_1, + g_variant_new_uint32(dn_data->time_level_1)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_DN_TIME_LEVEL_2, + g_variant_new_uint32(dn_data->time_level_2)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_DN_TIME_LEVEL_3, + g_variant_new_uint32(dn_data->time_level_3)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_DN_TIME_LEVEL_4, + g_variant_new_uint32(dn_data->time_level_4)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_DN_TIME_LEVEL_5, + g_variant_new_uint32(dn_data->time_level_5)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_DN_TIME_LEVEL_6, + g_variant_new_uint32(dn_data->time_level_6)); + + DBG("[Battery DN] rssi[%d/%d/%d/%d/%d/%d/%d]", + dn_data->time_level_0, dn_data->time_level_1, dn_data->time_level_2, + dn_data->time_level_3, dn_data->time_level_4, dn_data->time_level_5, + dn_data->time_level_6); + + if (dn_data->atm_list != NULL) { + GSList *list = NULL; + GVariantBuilder atm_builder; + + g_variant_builder_init(&atm_builder, G_VARIANT_TYPE("aa{sv}")); + + for (list = dn_data->atm_list; list != NULL; list = list->next) { + battery_app_data_s *app_data = (battery_app_data_s *)list->data; + + g_variant_builder_open(&atm_builder, G_VARIANT_TYPE("a{sv}")); + + g_variant_builder_add(&atm_builder, "{sv}", BATTERY_ATM_APP_ID, + g_variant_new_string(app_data->app_id)); + g_variant_builder_add(&atm_builder, "{sv}", BATTERY_ATM_RX, + g_variant_new_uint32(app_data->rx)); + g_variant_builder_add(&atm_builder, "{sv}", BATTERY_ATM_TX, + g_variant_new_uint32(app_data->tx)); + + g_variant_builder_close(&atm_builder); + + DBG("[Battery DN] app_id[%s] rx[%d] tx[%d]", app_data->app_id, app_data->rx, app_data->tx); + } + + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_ATM_LIST, + g_variant_new_variant(g_variant_builder_end(&atm_builder))); + } + + g_variant_builder_add_value(builder, g_variant_builder_end(&sub_builder)); +} + +static void __battery_get_wifi_list(void *data, battery_wifi_data_s *wifi_data) +{ + GVariantBuilder *builder = (GVariantBuilder *)data; + GVariantBuilder sub_builder; + + g_variant_builder_init(&sub_builder, G_VARIANT_TYPE("a{sv}")); + + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_WIFI_TIME_LEVEL_0, + g_variant_new_uint32(wifi_data->time_level_0)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_WIFI_TIME_LEVEL_1, + g_variant_new_uint32(wifi_data->time_level_1)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_WIFI_TIME_LEVEL_2, + g_variant_new_uint32(wifi_data->time_level_2)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_WIFI_TIME_LEVEL_3, + g_variant_new_uint32(wifi_data->time_level_3)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_WIFI_TIME_LEVEL_4, + g_variant_new_uint32(wifi_data->time_level_4)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_WIFI_START_TIME, + g_variant_new_uint32(wifi_data->start_time)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_WIFI_END_TIME, + g_variant_new_uint32(wifi_data->end_time)); + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_WIFI_SCAN_TIME, + g_variant_new_uint32(wifi_data->scan_time)); + + DBG("[Battery Wi-Fi] start[%ld] end[%ld] scan[%d] rssi[%d/%d/%d/%d/%d]", + wifi_data->start_time, wifi_data->end_time, wifi_data->scan_time, + wifi_data->time_level_0, wifi_data->time_level_1, wifi_data->time_level_2, + wifi_data->time_level_3, wifi_data->time_level_4); + + + if (wifi_data->atm_list != NULL) { + GSList *list = NULL; + GVariantBuilder atm_builder; + + g_variant_builder_init(&atm_builder, G_VARIANT_TYPE("aa{sv}")); + + for (list = wifi_data->atm_list; list != NULL; list = list->next) { + battery_app_data_s *app_data = (battery_app_data_s *)list->data; + + g_variant_builder_open(&atm_builder, G_VARIANT_TYPE("a{sv}")); + + g_variant_builder_add(&atm_builder, "{sv}", BATTERY_ATM_APP_ID, + g_variant_new_string(app_data->app_id)); + g_variant_builder_add(&atm_builder, "{sv}", BATTERY_ATM_RX, + g_variant_new_uint32(app_data->rx)); + g_variant_builder_add(&atm_builder, "{sv}", BATTERY_ATM_TX, + g_variant_new_uint32(app_data->tx)); + + g_variant_builder_close(&atm_builder); + + DBG("[Battery Wi-Fi] app_id[%s] rx[%d] tx[%d]", app_data->app_id, app_data->rx, app_data->tx); + } + + g_variant_builder_add(&sub_builder, "{sv}", BATTERY_ATM_LIST, + g_variant_new_variant(g_variant_builder_end(&atm_builder))); + } + + g_variant_builder_add_value(builder, g_variant_builder_end(&sub_builder)); +} + +void battery_update_dn_rssi(int rssi) +{ + struct timespec curr_timespec; + time_t curr_time; + + if (g_dn_data == NULL) + return; + + clock_gettime(CLOCK_MONOTONIC, &curr_timespec); + curr_time = curr_timespec.tv_sec; + + DBG("[Battery DN] rssi(%ld) [%d]", curr_time, rssi); + + if (g_dn_rssi_data.time != 0) { + uint diff_time = curr_time - g_dn_rssi_data.time; + diff_time = (diff_time > 0) ? diff_time : 1; + switch (g_dn_rssi_data.rssi) { + case 0: + g_dn_data->time_level_0 += diff_time; + DBG("[Battery DN] level 0 time [%d/%d]", diff_time, g_dn_data->time_level_0); + break; + case 1: + g_dn_data->time_level_1 += diff_time; + DBG("[Battery DN] level 1 time [%d/%d]", diff_time, g_dn_data->time_level_1); + break; + case 2: + g_dn_data->time_level_2 += diff_time; + DBG("[Battery DN] level 2 time [%d/%d]", diff_time, g_dn_data->time_level_2); + break; + case 3: + g_dn_data->time_level_3 += diff_time; + DBG("[Battery DN] level 3 time [%d/%d]", diff_time, g_dn_data->time_level_3); + break; + case 4: + g_dn_data->time_level_4 += diff_time; + DBG("[Battery DN] level 4 time [%d/%d]", diff_time, g_dn_data->time_level_4); + break; + case 5: + g_dn_data->time_level_5 += diff_time; + DBG("[Battery DN] level 5 time [%d/%d]", diff_time, g_dn_data->time_level_5); + break; + case 6: + g_dn_data->time_level_6 += diff_time; + DBG("[Battery DN] level 6 time [%d/%d]", diff_time, g_dn_data->time_level_6); + break; + default: + break; + } + } + + if (rssi >= 0) { + g_dn_rssi_data.time = curr_time; + g_dn_rssi_data.rssi = rssi; + } +} + +void battery_start_dn_data(void) +{ + battery_dn_data_s *dn_data = NULL; + struct timespec curr_timespec; + time_t curr_time; + + if (g_dn_data != NULL) + return; + + clock_gettime(CLOCK_MONOTONIC, &curr_timespec); + curr_time = curr_timespec.tv_sec; + + __battery_print_dn_list(); + + dn_data = (battery_dn_data_s *)g_try_malloc0(sizeof(battery_dn_data_s)); + if (dn_data == NULL) + return; + + memset(dn_data, 0, sizeof(battery_dn_data_s)); + dn_data->start_time = curr_time; + + g_dn_data = dn_data; + g_dn_list = g_slist_append(g_dn_list, g_dn_data); + + if (g_dn_rssi_data.time != 0) + g_dn_rssi_data.time = curr_time; + + DBG("[Battery DN] start(%ld)", g_dn_data->start_time); +} + +void battery_end_dn_data(int mode, stc_get_stats_cb get_stats_cb) +{ + struct timespec curr_timespec; + time_t curr_time; + + if (g_dn_data == NULL) + return; + + clock_gettime(CLOCK_MONOTONIC, &curr_timespec); + curr_time = curr_timespec.tv_sec; + + battery_update_dn_rssi(-1); + + if (mode == BATTERY_MODE_END) { + g_dn_rssi_data.time = 0; + g_dn_rssi_data.rssi = 0; + } + + g_dn_data->end_time = curr_time; + + get_stats_cb(g_dn_data->start_time, g_dn_data->end_time, &(g_dn_data->atm_list)); + + g_dn_data = NULL; + + DBG("[Battery DN] end"); +} + +void battery_update_wifi_scan(int state) +{ + struct timespec curr_timespec; + time_t curr_time; + + if (g_wifi_data == NULL) + return; + + clock_gettime(CLOCK_MONOTONIC, &curr_timespec); + curr_time = curr_timespec.tv_sec; + + switch (state) { + case 0: /* scan done */ + DBG("[Battery Wi-Fi] scan(%ld) [done]", curr_time); + if (g_wifi_scan_data.time != 0) { + uint diff_time = curr_time - g_wifi_scan_data.time; + diff_time = (diff_time > 0) ? diff_time : 1; + g_wifi_data->scan_time += diff_time; + DBG("[Battery Wi-Fi] scan time [%d/%d]", diff_time, g_wifi_data->scan_time); + } + break; + case 1: /* scan started */ + g_wifi_scan_data.time = curr_time; + DBG("[Battery Wi-Fi] scan(%ld) [started]", curr_time); + break; + default: + break; + } +} + +void battery_update_wifi_rssi(int rssi) +{ + struct timespec curr_timespec; + time_t curr_time; + + if (g_wifi_data == NULL) + return; + + clock_gettime(CLOCK_MONOTONIC, &curr_timespec); + curr_time = curr_timespec.tv_sec; + + DBG("[Battery Wi-Fi] rssi(%ld) [%d]", curr_time, rssi); + + if (g_wifi_rssi_data.time != 0) { + uint diff_time = curr_time - g_wifi_rssi_data.time; + diff_time = (diff_time > 0) ? diff_time : 1; + switch (g_wifi_rssi_data.rssi) { + case 0: + g_wifi_data->time_level_0 += diff_time; + DBG("[Battery Wi-Fi] level 0 time [%d/%d]", diff_time, g_wifi_data->time_level_0); + break; + case 1: + g_wifi_data->time_level_1 += diff_time; + DBG("[Battery Wi-Fi] level 1 time [%d/%d]", diff_time, g_wifi_data->time_level_1); + break; + case 2: + g_wifi_data->time_level_2 += diff_time; + DBG("[Battery Wi-Fi] level 2 time [%d/%d]", diff_time, g_wifi_data->time_level_2); + break; + case 3: + g_wifi_data->time_level_3 += diff_time; + DBG("[Battery Wi-Fi] level 3 time [%d/%d]", diff_time, g_wifi_data->time_level_3); + break; + case 4: + g_wifi_data->time_level_4 += diff_time; + DBG("[Battery Wi-Fi] level 4 time [%d/%d]", diff_time, g_wifi_data->time_level_4); + break; + default: + break; + } + } + + if (rssi >= 0) { + g_wifi_rssi_data.time = curr_time; + g_wifi_rssi_data.rssi = rssi; + } +} + +void battery_start_wifi_data(void) +{ + battery_wifi_data_s *wifi_data = NULL; + struct timespec curr_timespec; + time_t curr_time; + + if (g_wifi_data != NULL) + return; + + clock_gettime(CLOCK_MONOTONIC, &curr_timespec); + curr_time = curr_timespec.tv_sec; + + __battery_print_wifi_list(); + + wifi_data = (battery_wifi_data_s *)g_try_malloc0(sizeof(battery_wifi_data_s)); + if (wifi_data == NULL) + return; + + memset(wifi_data, 0, sizeof(battery_wifi_data_s)); + wifi_data->start_time = curr_time; + + g_wifi_data = wifi_data; + g_wifi_list = g_slist_append(g_wifi_list, g_wifi_data); + + if (g_wifi_rssi_data.time) + g_wifi_rssi_data.time = curr_time; + + DBG("[Battery Wi-Fi] start(%ld)", g_wifi_data->start_time); +} + +void battery_end_wifi_data(int mode, stc_get_stats_cb get_stats_cb) +{ + struct timespec curr_timespec; + time_t curr_time; + + if (g_wifi_data == NULL) + return; + + clock_gettime(CLOCK_MONOTONIC, &curr_timespec); + curr_time = curr_timespec.tv_sec; + + battery_update_wifi_rssi(-1); + + if (mode == BATTERY_MODE_END) { + g_wifi_rssi_data.time = 0; + g_wifi_rssi_data.rssi = 0; + } + + g_wifi_scan_data.time = 0; + + g_wifi_data->end_time = curr_time; + + get_stats_cb(g_wifi_data->start_time, g_wifi_data->end_time, &(g_wifi_data->atm_list)); + + g_wifi_data = NULL; + + DBG("[Battery Wi-Fi] end(%ld)", curr_time); +} + +void battery_get_dn_list(void *data, stc_get_stats_cb get_stats_cb) +{ + GSList *dn_list = NULL; + int cont = FALSE; + + if (g_dn_data != NULL) + cont = TRUE; + + battery_end_dn_data(BATTERY_MODE_GET, get_stats_cb); + + DBG("==============================================================="); + + for (dn_list = g_dn_list; dn_list != NULL; dn_list = dn_list->next) { + battery_dn_data_s *dn_data = (battery_dn_data_s *)dn_list->data; + __battery_get_dn_list(data, dn_data); + DBG("==============================================================="); + } + + __battery_flush_dn_list(); + + if (cont) + battery_start_dn_data(); +} + +void battery_get_wifi_list(void *data, stc_get_stats_cb get_stats_cb) +{ + GSList *list = NULL; + int cont = FALSE; + + if (g_wifi_data != NULL) + cont = TRUE; + + battery_end_wifi_data(BATTERY_MODE_GET, get_stats_cb); + + DBG("==============================================================="); + + for (list = g_wifi_list; list != NULL; list = list->next) { + battery_wifi_data_s *wifi_data = (battery_wifi_data_s *)list->data; + __battery_get_wifi_list(data, wifi_data); + DBG("==============================================================="); + } + + __battery_flush_wifi_list(); + + if (cont) + battery_start_wifi_data(); +} + +extern struct netconfig_battery_plugin_t netconfig_battery_plugin + __attribute__ ((visibility("default"))); +struct netconfig_battery_plugin_t netconfig_battery_plugin = { + battery_start_dn_data, + battery_end_dn_data, + battery_update_dn_rssi, + battery_start_wifi_data, + battery_end_wifi_data, + battery_update_wifi_scan, + battery_update_wifi_rssi, + battery_get_dn_list, + battery_get_wifi_list +}; diff --git a/plugin/stc/CMakeLists.txt b/plugin/stc/CMakeLists.txt new file mode 100755 index 0000000..1a29425 --- /dev/null +++ b/plugin/stc/CMakeLists.txt @@ -0,0 +1,42 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(net-config-plugin-stc C) + +IF(TIZEN_WEARABLE) + ADD_DEFINITIONS(-DTIZEN_WEARABLE) +ENDIF(TIZEN_WEARABLE) + +ADD_DEFINITIONS(-DUSE_NETCONFIG_LOG) + +# Set required packages +INCLUDE(FindPkgConfig) +PKG_CHECK_MODULES(pkgs_stc REQUIRED + dlog + vconf + gio-2.0 + gio-unix-2.0 + glib-2.0 + capi-network-stc + ) + +FOREACH(flag ${pkgs_stc_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include) +# INCLUDE_DIRECTORIES(SRCS include) + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -g -Werror") +SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") +SET(CMAKE_C_FLAGS_RELEASE "-O2") + +SET(SRCS_STC + stc.c + ) + +# library build +ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS_STC}) +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_stc_LDFLAGS}) +SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES PREFIX "" OUTPUT_NAME ${PROJECT_NAME}) + +# install +INSTALL(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${LIBDIR}) diff --git a/plugin/stc/stc.c b/plugin/stc/stc.c new file mode 100755 index 0000000..6827bd6 --- /dev/null +++ b/plugin/stc/stc.c @@ -0,0 +1,218 @@ +/* + * Network Configuration Module + * + * Copyright (c) 2017 Samsung Electronics Co., Ltd. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include "plugin.h" +#include "netdbus.h" +#include + +#ifdef USE_NETCONFIG_LOG +#include "log.h" +#else +#include + +#define NETCONFIG_TAG "NETCONFIG" +#define __LOG(level, format, arg...) \ + do { \ + SLOG(level, NETCONFIG_TAG, format, ## arg); \ + } while (0) + +#define DBG(format, arg...) __LOG(LOG_DEBUG, format, ## arg) +#define ERR(format, arg...) __LOG(LOG_ERROR, format, ## arg) +#endif + +#define STC_DBUS_REPLY_TIMEOUT (120 * 1000) + +#define STC_MANAGER_SERVICE "net.stc" +#define STC_MANAGER_STATS_PATH "/net/stc/statistics" +#define STC_MANAGER_STATS_INTERFACE STC_MANAGER_SERVICE ".statistics" +#define STC_MANAGER_METHOD_STATS_GET_ALL "GetAll" + +#define STC_STATS_INFO_APP_ID "app_id" +#define STC_STATS_INFO_INCOMING_BYTES "cnt_in_bytes" +#define STC_STATS_INFO_OUTGOING_BYTES "cnt_out_bytes" + +typedef void (*stc_dbus_dict_cb) (const char *key, GVariant *value, void *user_data); + +static GVariant *__invoke_dbus_method(const char *dest, const char *path, + const char *interface_name, const char *method, GVariant *params) +{ + + GError *error = NULL; + GVariant *reply = NULL; + GDBusConnection *connection; + + connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); + if (connection == NULL) { + ERR("[STC] Failed to get GDBusconnection"); + return reply; + } + + reply = g_dbus_connection_call_sync( + connection, + dest, + path, + interface_name, + method, + params, + NULL, + G_DBUS_CALL_FLAGS_NONE, + STC_DBUS_REPLY_TIMEOUT, + NULL, + &error); + + g_object_unref(connection); + + if (reply == NULL) { + if (error != NULL) { + ERR("[STC] g_dbus_connection_call_sync() failed" + "error [%d: %s]", error->code, error->message); + g_error_free(error); + } else { + ERR("[STC] g_dbus_connection_call_sync() failed"); + } + + return NULL; + } + + return reply; +} + +static void __stc_extract_cb(const char *key, GVariant *value, void *user_data) +{ + battery_app_data_s *app_data = (battery_app_data_s *)user_data; + + if (app_data == NULL) + return; + + if (!g_strcmp0(key, STC_STATS_INFO_APP_ID)) { + const char *app_id = g_variant_get_string(value, NULL); + app_data->app_id = g_strdup(app_id); + } else if (!g_strcmp0(key, STC_STATS_INFO_INCOMING_BYTES)) { + app_data->rx = g_variant_get_int64(value); + } else if (!g_strcmp0(key, STC_STATS_INFO_OUTGOING_BYTES)) { + app_data->tx = g_variant_get_int64(value); + } +} + +static void __stc_dbus_dictionary_foreach(GVariantIter *iter, + stc_dbus_dict_cb cb, void *user_data) +{ + char *key = NULL; + GVariant *value = NULL; + + if (!cb) + return; + + while (g_variant_iter_loop(iter, "{sv}", &key, &value)) { + if (key) + cb(key, value, user_data); + } +} + +static void __stc_get_stats(GVariant *params, GSList **list) +{ + GVariant *message = NULL; + GVariantIter *iter = NULL; + GVariantIter *iter_row = NULL; + stc_error_e dbus_result = STC_ERROR_NONE; + + message = __invoke_dbus_method(STC_MANAGER_SERVICE, + STC_MANAGER_STATS_PATH, STC_MANAGER_STATS_INTERFACE, + STC_MANAGER_METHOD_STATS_GET_ALL, params); + + if (message == NULL) + return; + + g_variant_get(message, "(iaa{sv})", &dbus_result, &iter); + + while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { + battery_app_data_s *app_data = g_try_malloc0(sizeof(battery_app_data_s)); + if (app_data != NULL) { + memset(app_data, 0, sizeof(battery_app_data_s)); + + __stc_dbus_dictionary_foreach(iter_row, __stc_extract_cb, app_data); + + if (strstr(app_data->app_id, "TOTAL_") != NULL) { + g_free(app_data->app_id); + g_free(app_data); + } else { + *list = g_slist_append(*list, app_data); + } + } + g_variant_iter_free(iter_row); + } + + g_variant_iter_free(iter); + g_variant_unref(message); +} + +static void __stc_print_stats(GSList *list) +{ + GSList *stats_list = NULL; + + for (stats_list = list; stats_list != NULL; stats_list = stats_list->next) { + battery_app_data_s *app_data = (battery_app_data_s *)stats_list->data; + + DBG("[STC] app_id[%s] rx[%d] tx[%d]", app_data->app_id, app_data->rx, app_data->tx); + } +} + +static void __stc_make_params(time_t from, time_t to, stc_iface_type_e iftype, GVariant **params) +{ + GVariantBuilder *builder; + + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + + g_variant_builder_add(builder, "{sv}", "from", g_variant_new_uint64(from)); + g_variant_builder_add(builder, "{sv}", "to", g_variant_new_uint64(to)); + g_variant_builder_add(builder, "{sv}", "iftype", g_variant_new_uint16(iftype)); + + *params = g_variant_new("(@a{sv})", g_variant_builder_end(builder)); + + g_variant_builder_unref(builder); +} + +void stc_get_dn_stats(time_t from, time_t to, GSList **list) +{ + GVariant *params = NULL; + + DBG("[STC] DN stats from [%ld] to [%ld]", from, to); + + __stc_make_params(from, to, STC_IFACE_DATACALL, ¶ms); + __stc_get_stats(params, list); + __stc_print_stats(*list); +} + +void stc_get_wifi_stats(time_t from, time_t to, GSList **list) +{ + GVariant *params = NULL; + + DBG("[STC] wi-fi stats from [%ld] to [%ld]", from, to); + + __stc_make_params(from, to, STC_IFACE_WIFI, ¶ms); + __stc_get_stats(params, list); + __stc_print_stats(*list); +} + +extern struct netconfig_stc_plugin_t netconfig_stc_plugin + __attribute__ ((visibility("default"))); +struct netconfig_stc_plugin_t netconfig_stc_plugin = { + stc_get_dn_stats, + stc_get_wifi_stats +}; diff --git a/src/network-state.c b/src/network-state.c index 84de50a..dfdc8c0 100755 --- a/src/network-state.c +++ b/src/network-state.c @@ -95,6 +95,7 @@ static Network *netconfigstate = NULL; #if defined TIZEN_DEBUG_ENABLE static Tcpdump *tcpdump_object = NULL; #endif +static Battery *battery_object = NULL; struct netconfig_default_connection { char *profile; @@ -1503,6 +1504,50 @@ gboolean handle_preferred_ipv6_address(Network *object, return TRUE; } +gboolean handle_get_battery_dn_list(Battery *object, + GDBusMethodInvocation *context) +{ + GVariantBuilder *builder = NULL; + GVariant *ret_params = NULL; + gchar *params_str = NULL; + + builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}")); + + netconfig_battery_get_dn_list(builder); + + ret_params = g_variant_builder_end(builder); + if (ret_params) { + params_str = g_variant_print(ret_params, TRUE); + DBG("DN list [%s]", params_str); + } + + battery_complete_get_battery_dn_list(object, context, ret_params); + g_variant_builder_unref(builder); + return TRUE; +} + +gboolean handle_get_battery_wifi_list(Battery *object, + GDBusMethodInvocation *context) +{ + GVariantBuilder *builder = NULL; + GVariant *ret_params = NULL; + gchar *params_str = NULL; + + builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}")); + + netconfig_battery_get_wifi_list(builder); + + ret_params = g_variant_builder_end(builder); + if (ret_params) { + params_str = g_variant_print(ret_params, TRUE); + DBG("Wi-Fi list [%s]", params_str); + } + + battery_complete_get_battery_wifi_list(object, context, ret_params); + g_variant_builder_unref(builder); + return TRUE; +} + void state_object_create_and_init(void) { DBG("Creating network state object"); @@ -1510,6 +1555,7 @@ void state_object_create_and_init(void) #if defined TIZEN_DEBUG_ENABLE GDBusInterfaceSkeleton *interface_tcpdump = NULL; #endif + GDBusInterfaceSkeleton *interface_battery = NULL; GDBusConnection *connection = NULL; GDBusObjectManagerServer *server = netdbus_get_state_manager(); if (server == NULL) @@ -1571,6 +1617,19 @@ void state_object_create_and_init(void) ERR("Export with path failed"); } #endif + + battery_object = battery_skeleton_new(); + + interface_battery = G_DBUS_INTERFACE_SKELETON(battery_object); + g_signal_connect(battery_object, "handle-get-battery-dn-list", + G_CALLBACK(handle_get_battery_dn_list), NULL); + g_signal_connect(battery_object, "handle-get-battery-wifi-list", + G_CALLBACK(handle_get_battery_wifi_list), NULL); + + if (!g_dbus_interface_skeleton_export(interface_battery, connection, + NETCONFIG_NETWORK_STATE_PATH, NULL)) { + ERR("Export with path failed"); + } } void state_object_deinit(void) diff --git a/src/signal-handler.c b/src/signal-handler.c index 93373ff..3894c48 100755 --- a/src/signal-handler.c +++ b/src/signal-handler.c @@ -53,6 +53,7 @@ #define DBUS_INTERFACE_DBUS "org.freedesktop.DBus" #define SIGNAL_INTERFACE_REMOVED "InterfaceRemoved" #define SIGNAL_SCAN_DONE "ScanDone" +#define SIGNAL_SCAN_CHANGED "ScanChanged" #define SIGNAL_BSS_ADDED "BSSAdded" #define SIGNAL_PROPERTIES_CHANGED "PropertiesChanged" #define SIGNAL_PROPERTIES_DRIVER_HANGED "DriverHanged" @@ -448,11 +449,12 @@ static void _service_signal_cb(GDBusConnection *conn, } else { if (g_strcmp0(property, "ready") == 0 || g_strcmp0(property, "online") == 0) { if (netconfig_get_default_profile() == NULL) { - if (!netconfig_is_cellular_profile(path)) + if (!netconfig_is_cellular_profile(path)) { netconfig_update_default_profile(path); - else { - if (netconfig_is_cellular_internet_profile(path)) + } else { + if (netconfig_is_cellular_internet_profile(path)) { netconfig_update_default_profile(path); + } } } else { pf = netconfig_get_connected_cellular_internet_ipv6only_profile(NULL); @@ -722,6 +724,30 @@ static void _services_changed_cb(GDBusConnection *conn, const gchar *name, return; } +static void _scan_changed_cb(GDBusConnection *conn, + const gchar *name, const gchar *path, const gchar *interface, + const gchar *sig, GVariant *param, gpointer user_data) +{ + const char *key = NULL; + GVariant *var; + gboolean value = false; + + if (g_strcmp0(sig, SIGNAL_SCAN_CHANGED) == 0) { + g_variant_get(param, "(sv)", &key, &var); + + if (g_strcmp0(key, "scan_started") == 0) + value = true; + else if (g_strcmp0(key, "scan_done") == 0) + value = false; + + DBG("Scan changed [%s]", (value == true) ? "Started" : "Done"); + netconfig_battery_update_wifi_scan(value); + + if (var != NULL) + g_variant_unref(var); + } +} + static void _supplicant_interface_removed(GDBusConnection *conn, const gchar *name, const gchar *path, const gchar *interface, const gchar *sig, GVariant *param, gpointer user_data) @@ -1288,6 +1314,86 @@ static void __netconfig_wps_signal_filter_handler(GDBusConnection *conn, return; } +static void __telephony_svc_cs_changed_cb(keynode_t * node, void *data) +{ + int telephony_svc_cs = 0; + + if (node != NULL) + telephony_svc_cs = vconf_keynode_get_int(node); + else + netconfig_vconf_get_int(VCONFKEY_TELEPHONY_SVC_CS, &telephony_svc_cs); + + DBG("Telephony svc cs [%d]", telephony_svc_cs); + + switch (telephony_svc_cs) { + case 1: + netconfig_battery_end_dn(); + break; + case 2: + netconfig_battery_start_dn(); + break; + default: + break; + } +} + +static void __telephony_rssi_changed_cb(keynode_t * node, void *data) +{ + int rssi = 0; + + if (node != NULL) + rssi = vconf_keynode_get_int(node); + else + netconfig_vconf_get_int(VCONFKEY_TELEPHONY_RSSI, &rssi); + + DBG("Telephony rssi [%d]", rssi); + + netconfig_battery_update_dn_rssi(rssi); +} + +static void _notify_telephony_svc_cs(void) +{ + int telephony_svc_cs = 0; + + netconfig_vconf_get_int(VCONFKEY_TELEPHONY_SVC_CS, &telephony_svc_cs); + DBG("Telephony svc cs [%d]", telephony_svc_cs); + + switch (telephony_svc_cs) { + case 1: + netconfig_battery_end_dn(); + break; + case 2: + netconfig_battery_start_dn(); + break; + default: + break; + } + + vconf_notify_key_changed(VCONFKEY_TELEPHONY_SVC_CS, __telephony_svc_cs_changed_cb, NULL); +} + +static void _notify_telephony_rssi(void) +{ + int rssi = 0; + + netconfig_vconf_get_int(VCONFKEY_TELEPHONY_RSSI, &rssi); + DBG("Telephony rssi [%d]", rssi); + + netconfig_battery_update_dn_rssi(rssi); + + vconf_notify_key_changed(VCONFKEY_TELEPHONY_RSSI, __telephony_rssi_changed_cb, NULL); +} + +static void _ignore_telephony_svc_cs(void) +{ + vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SVC_CS, __telephony_svc_cs_changed_cb); +} + +static void _ignore_telephony_rssi(void) +{ + vconf_ignore_key_changed(VCONFKEY_TELEPHONY_RSSI, __telephony_rssi_changed_cb); +} + static supplicant_signal_cb supplicant_cbs[SIG_MAX] = { _supplicant_interface_removed, _supplicant_properties_changed, @@ -1370,9 +1476,21 @@ void register_gdbus_signal(void) NULL, NULL); + conn_subscription_ids[4] = g_dbus_connection_signal_subscribe( + connection, + CONNMAN_SERVICE, + CONNMAN_MANAGER_INTERFACE, + SIGNAL_SCAN_CHANGED, + CONNMAN_MANAGER_PATH, + NULL, + G_DBUS_SIGNAL_FLAGS_NONE, + _scan_changed_cb, + NULL, + NULL); + INFO("Successfully register connman DBus signal filters"); - conn_subscription_ids[4] = g_dbus_connection_signal_subscribe( + conn_subscription_ids[5] = g_dbus_connection_signal_subscribe( connection, SUPPLICANT_SERVICE, SUPPLICANT_INTERFACE ".Interface.WPS", @@ -1432,6 +1550,11 @@ void register_gdbus_signal(void) INFO("Successfully registered Dumpservice DBus signal filter"); #endif + _notify_telephony_svc_cs(); + _notify_telephony_rssi(); + + INFO("Successfully register Telephony vconf keys"); + /* In case ConnMan precedes this signal register, * net-config should update the default connected profile. */ @@ -1467,4 +1590,7 @@ void deregister_gdbus_signal(void) g_dbus_connection_signal_unsubscribe(connection, dumpservice_subscription_id); #endif + + _ignore_telephony_svc_cs(); + _ignore_telephony_rssi(); } diff --git a/src/utils/util.c b/src/utils/util.c index dc31b6d..8d41a76 100755 --- a/src/utils/util.c +++ b/src/utils/util.c @@ -49,6 +49,8 @@ #define MAC_ADDRESS_MAX_LEN 18 #define HEADED_PLUGIN_FILEPATH "/usr/lib/net-config-plugin-headed.so" #define TELEPHONY_PLUGIN_FILEPATH "/usr/lib/net-config-plugin-telephony.so" +#define STC_PLUGIN_FILEPATH "/usr/lib/net-config-plugin-stc.so" +#define BATTERY_PLUGIN_FILEPATH "/usr/lib/net-config-plugin-battery.so" static gboolean netconfig_device_picker_test = FALSE; static int mdnsd_ref_count = 0; @@ -59,10 +61,16 @@ typedef struct { static gboolean netconfig_plugin_headed_enabled = FALSE; static gboolean netconfig_plugin_telephony_enabled = FALSE; +static gboolean netconfig_plugin_stc_enabled = FALSE; +static gboolean netconfig_plugin_battery_enabled = FALSE; static void *handle_headed; static void *handle_telephony; +static void *handle_stc; +static void *handle_battery; static struct netconfig_headed_plugin_t *headed_plugin; static struct netconfig_telephony_plugin_t *telephony_plugin; +static struct netconfig_stc_plugin_t *stc_plugin; +static struct netconfig_battery_plugin_t *battery_plugin; static bool is_feature_checked[NETCONFIG_SUPPORTED_FEATURE_MAX] = {0, }; static bool feature_supported[NETCONFIG_SUPPORTED_FEATURE_MAX] = {0, }; @@ -1130,6 +1138,127 @@ gboolean __netconfig_wifi_get_sim_authdata(Wifi *wifi, return telephony_plugin->wifi_get_sim_authdata(wifi, context, data); } +static void __netconfig_stc_get_dn_stats(time_t from, time_t to, GSList **list) +{ + if (!netconfig_plugin_stc_enabled) + return; + + if (!stc_plugin) + return; + + return stc_plugin->get_stc_dn_stats(from, to, list); +} + +static void __netconfig_stc_get_wifi_stats(time_t from, time_t to, GSList **list) +{ + if (!netconfig_plugin_stc_enabled) + return; + + if (!stc_plugin) + return; + + return stc_plugin->get_stc_wifi_stats(from, to, list); +} + +void netconfig_battery_start_dn(void) +{ + if (!netconfig_plugin_battery_enabled) + return; + + if (!battery_plugin) + return; + + return battery_plugin->start_dn_data(); +} + +void netconfig_battery_end_dn(void) +{ + if (!netconfig_plugin_battery_enabled) + return; + + if (!battery_plugin) + return; + + return battery_plugin->end_dn_data(0, __netconfig_stc_get_dn_stats); +} + +void netconfig_battery_update_dn_rssi(int rssi) +{ + if (!netconfig_plugin_battery_enabled) + return; + + if (!battery_plugin) + return; + + return battery_plugin->update_dn_rssi(rssi); +} + +void netconfig_battery_start_wifi(void) +{ + if (!netconfig_plugin_battery_enabled) + return; + + if (!battery_plugin) + return; + + return battery_plugin->start_wifi_data(); +} + +void netconfig_battery_end_wifi(void) +{ + if (!netconfig_plugin_battery_enabled) + return; + + if (!battery_plugin) + return; + + return battery_plugin->end_wifi_data(0, __netconfig_stc_get_wifi_stats); +} + +void netconfig_battery_update_wifi_scan(int state) +{ + if (!netconfig_plugin_battery_enabled) + return; + + if (!battery_plugin) + return; + + return battery_plugin->update_wifi_scan(state); +} + +void netconfig_battery_update_wifi_rssi(int rssi) +{ + if (!netconfig_plugin_battery_enabled) + return; + + if (!battery_plugin) + return; + + return battery_plugin->update_wifi_rssi(rssi); +} + +void netconfig_battery_get_dn_list(void *data) +{ + if (!netconfig_plugin_battery_enabled) + return; + + if (!battery_plugin) + return; + + return battery_plugin->get_battery_dn_list(data, __netconfig_stc_get_dn_stats); +} + +void netconfig_battery_get_wifi_list(void *data) +{ + if (!netconfig_plugin_battery_enabled) + return; + + if (!battery_plugin) + return; + + return battery_plugin->get_battery_wifi_list(data, __netconfig_stc_get_wifi_stats); +} + void netconfig_set_vconf_int(const char * key, int value) { int ret = 0; @@ -1389,6 +1518,33 @@ void netconfig_plugin_init() netconfig_plugin_telephony_enabled = TRUE; } } + + handle_stc = dlopen(STC_PLUGIN_FILEPATH, RTLD_NOW); + if (!handle_stc) { + ERR("Can't load %s: %s", STC_PLUGIN_FILEPATH, dlerror()); + } else { + stc_plugin = dlsym(handle_stc, "netconfig_stc_plugin"); + if (!stc_plugin) { + ERR("Can't load symbol: %s", dlerror()); + dlclose(handle_stc); + } else { + netconfig_plugin_stc_enabled = TRUE; + } + } + + handle_battery = dlopen(BATTERY_PLUGIN_FILEPATH, RTLD_NOW); + if (!handle_battery) { + ERR("Can't load %s: %s", BATTERY_PLUGIN_FILEPATH, dlerror()); + } else { + battery_plugin = dlsym(handle_battery, "netconfig_battery_plugin"); + if (!battery_plugin) { + ERR("Can't load symbol: %s", dlerror()); + dlclose(handle_battery); + } else { + netconfig_plugin_battery_enabled = TRUE; + } + } + } void netconfig_plugin_deinit() @@ -1402,6 +1558,17 @@ void netconfig_plugin_deinit() netconfig_plugin_telephony_enabled = FALSE; dlclose(handle_telephony); } + + if (netconfig_plugin_stc_enabled) { + netconfig_plugin_stc_enabled = FALSE; + dlclose(handle_stc); + } + + if (netconfig_plugin_battery_enabled) { + netconfig_plugin_battery_enabled = FALSE; + dlclose(handle_battery); + } + } gboolean netconfig_get_headed_plugin_flag() diff --git a/src/wifi-indicator.c b/src/wifi-indicator.c index 4bc18c6..2af498e 100755 --- a/src/wifi-indicator.c +++ b/src/wifi-indicator.c @@ -197,6 +197,7 @@ static void __netconfig_wifi_set_rssi_level(const int snr_level) if (snr_level != last_snr_level) { netconfig_set_vconf_int(VCONFKEY_WIFI_STRENGTH, snr_level); + netconfig_battery_update_wifi_rssi(snr_level); last_snr_level = snr_level; } } @@ -372,6 +373,7 @@ void netconfig_wifi_indicator_start(void) netconfig_set_vconf_int(VCONFKEY_WIFI_STRENGTH, VCONFKEY_WIFI_STRENGTH_MAX); __wifi_indicator_monitor(&netconfig_wifi_indicator_timer); + netconfig_battery_update_wifi_rssi(VCONFKEY_WIFI_STRENGTH_MAX); netconfig_start_timer_seconds(WIFI_INDICATOR_INTERVAL, __wifi_indicator_monitor, NULL, &netconfig_wifi_indicator_timer); } diff --git a/src/wifi-state.c b/src/wifi-state.c index 237e2e0..c6b964f 100755 --- a/src/wifi-state.c +++ b/src/wifi-state.c @@ -439,6 +439,7 @@ void wifi_state_update_power_state(gboolean powered) wifi_state_set_tech_state(NETCONFIG_WIFI_TECH_POWERED); wifi_state_emit_power_completed(TRUE); + netconfig_battery_start_wifi(); netconfig_wifi_device_picker_service_start(); @@ -466,6 +467,7 @@ void wifi_state_update_power_state(gboolean powered) wifi_power_driver_and_supplicant(FALSE); wifi_state_emit_power_completed(FALSE); + netconfig_battery_end_wifi(); netconfig_set_vconf_int(VCONF_WIFI_LAST_POWER_STATE, VCONFKEY_WIFI_OFF); netconfig_set_vconf_int(VCONFKEY_WIFI_STATE, VCONFKEY_WIFI_OFF); -- 2.34.1