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)
#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"
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,
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();
<arg type="b" name="state" direction="out"/>
</method>
</interface>
+ <interface name="net.netconfig.battery">
+ <method name="GetBatteryDnList">
+ <arg type="aa{sv}" name="dn_list" direction="out"/>
+ </method>
+ <method name="GetBatteryWifiList">
+ <arg type="aa{sv}" name="wifi_list" direction="out"/>
+ </method>
+ </interface>
</node>
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
%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)
%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
--- /dev/null
+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})
--- /dev/null
+/*
+ * 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 <dlog.h>
+
+#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
+};
--- /dev/null
+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})
--- /dev/null
+/*
+ * 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 <stc.h>
+
+#ifdef USE_NETCONFIG_LOG
+#include "log.h"
+#else
+#include <dlog.h>
+
+#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
+};
#if defined TIZEN_DEBUG_ENABLE
static Tcpdump *tcpdump_object = NULL;
#endif
+static Battery *battery_object = NULL;
struct netconfig_default_connection {
char *profile;
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");
#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)
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)
#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"
} 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);
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)
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,
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",
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.
*/
g_dbus_connection_signal_unsubscribe(connection,
dumpservice_subscription_id);
#endif
+
+ _ignore_telephony_svc_cs();
+ _ignore_telephony_rssi();
}
#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;
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, };
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;
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()
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()
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;
}
}
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);
}
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();
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);
projects / platform / core / connectivity / net-config.git / commitdiff