CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+ADD_SUBDIRECTORY(plugin/cpu)
+
ADD_SUBDIRECTORY(plugin/dummy)
%description
Battery-Monitor plugins
+%package cpu
+Summary: Battery-Monitor CPU plugin
+BuildRequires: pkgconfig(capi-appfw-app-manager)
+BuildRequires: pkgconfig(capi-system-runtime-info)
+BuildRequires: pkgconfig(sqlite3)
+
+%description cpu
+CPU plugin for Battery-Monitor
+
%package dummy
Summary: Battery-Monitor dummy plugin
%postun -p /sbin/ldconfig
+%files cpu
+%manifest %{name}.manifest
+%license LICENSE
+%{BATTERY_MONITOR_LIBDIR}/lib%{name}-cpu*
+
%files dummy
%manifest %{name}.manifest
%license LICENSE
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT("batterymonitor-plugins-cpu" C)
+
+SET(CMAKE_INSTALL_PREFIX /usr)
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+
+SET(PKG_MODULES
+ capi-appfw-app-manager
+ capi-system-runtime-info
+ dlog
+ glib-2.0
+ sqlite3
+)
+INCLUDE(FindPkgConfig)
+pkg_check_modules(${PROJECT_NAME} REQUIRED ${PKG_MODULES})
+
+FOREACH(flag ${${PROJECT_NAME}_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror -fvisibility=hidden")
+SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+
+SET(SOURCES
+ src/bm_cpu_plugin.c
+)
+
+ADD_LIBRARY(${PROJECT_NAME} SHARED ${SOURCES})
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${${PROJECT_NAME}_LDFLAGS})
+SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES
+ VERSION ${FULLVER} SOVERSION ${MAJORVER} CLEAN_DIRECT_OUTPUT 1)
+
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${BATTERY_MONITOR_LIBDIR})
--- /dev/null
+/*
+ * Copyright (c) 2019 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.
+ *
+ */
+
+#ifndef __BM_CPU_UTIL_H__
+#define __BM_CPU_UTIL_H__
+
+#include <stdlib.h>
+#include <tizen.h>
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NAME "cpu_plugin"
+#define AUTHOR "SAMSUNG"
+#define VERSION "0.1"
+
+#define BUFFER_SZ 200
+
+#define STATUS_SUCCESS 1
+#define STATUS_FAILURE 0
+
+
+#define BMP_RETURN_VAL(eval, expr, ret_val, X) \
+ if (!(eval)) { \
+ expr; \
+ return ret_val; \
+ } else {}
+
+#define BMP_SNPRINTF(dest, size, format, arg...) \
+ do { \
+ snprintf(dest, size-1, format, ##arg); \
+ } while (0)
+
+#define BMP_MEMSET(dest, value, size) \
+ do { \
+ memset(dest, value, size); \
+ } while (0)
+
+#define BMP_CATCH_ERROR(eval, expr, error_val, X) \
+ if (!(eval)) { \
+ expr; \
+ error_code = (error_val); \
+ goto CATCH; \
+ } else {}
+
+#define BMP_CATCH_ERROR_P(eval, expr, error_val, X) \
+ if (!(eval)) { \
+ expr; \
+ *error_code = (error_val); \
+ goto CATCH; \
+ } else { }
+
+#define BMP_FREE(ptr)ptr \
+ if (ptr != NULL) { \
+ free(ptr); \
+ ptr = NULL; \
+ } \
+
+#define BMP_GFREE(ptr)ptr \
+ if (ptr != NULL) { \
+ g_free(ptr); \
+ ptr = NULL; \
+ } \
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __BM_CPU_UTIL_H__ */
+
+
--- /dev/null
+/*
+ * Copyright (c) 2019 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.
+ *
+ */
+
+#ifndef __BM_LOG_H__
+#define __BM_LOG_H__
+
+#include <dlog.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "BM_CPU_PLUGIN"
+
+#ifndef _BME
+#define _E(fmt, args...) LOGE("[%s:%d] "fmt"\n", __func__, __LINE__, ##args)
+#endif
+
+#ifndef _BMD
+#define _D(fmt, args...) LOGD("[%s:%d] "fmt"\n", __func__, __LINE__, ##args)
+#endif
+
+#ifndef _BMI
+#define _I(fmt, args...) LOGI("[%s:%d] "fmt"\n", __func__, __LINE__, ##args)
+#endif
+
+#ifndef _BMW
+#define _W(fmt, args...) LOGW("[%s:%d] "fmt"\n", __func__, __LINE__, ##args)
+#endif
+
+#define ENTER dlog_print(DLOG_DEBUG, LOG_TAG, "%s : %s(%d) >>>>>>>> called", rindex(__FILE__, '/') + 1, __func__, __LINE__)
+#define EXIT dlog_print(DLOG_DEBUG, LOG_TAG, "%s : %s(%d) <<<<<<<< ended", rindex(__FILE__, '/') + 1, __func__, __LINE__)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __BM_LOG_H__ */
+
+
--- /dev/null
+/*
+ * Copyright (c) 2018 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.
+ *
+ */
+
+#ifndef __BM_PLUGIN_INTERFACE_H__
+#define __BM_PLUGIN_INTERFACE_H__
+
+#include <stdio.h>
+#include <gmodule.h>
+#include <time.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef unsigned int uint;
+typedef unsigned char uchar;
+
+#define BM_DATA_TYPE_MAX (BM_DATA_TYPE_BATTERY + 1)
+#define BM_PLUGIN_ID_MAX (BM_PLUGIN_ID_BATTERY + 1)
+#define BM_DURATION_TYPE_MAX (BM_DURATION_TYPE_1WEEK + 1)
+
+typedef enum {
+ BM_PLUGIN_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
+ BM_PLUGIN_ERROR_NO_DATA = TIZEN_ERROR_NO_DATA, /**< No data */
+ BM_PLUGIN_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+ BM_PLUGIN_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
+ BM_PLUGIN_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
+ BM_PLUGIN_ERROR_SERVICE_UNAVAILABLE = TIZEN_ERROR_UNKNOWN - 1 /**< Service unavailable */
+} bm_plugin_error_e;
+
+/*
+ * enum for plugin identifier
+ */
+typedef enum {
+ BM_PLUGIN_ID_BLE=0, /**< Bluetooth Low Energy */
+ BM_PLUGIN_ID_WIFI, /**< Wi-Fi */
+ BM_PLUGIN_ID_CPU, /**< CPU */
+ BM_PLUGIN_ID_DISPLAY, /**< Display */
+ BM_PLUGIN_ID_DEVICE_NETWORK, /**< Network */
+ BM_PLUGIN_ID_GPS_SENSOR, /**< GPS */
+ BM_PLUGIN_ID_HRM_SENSOR, /**< Heart Rate Monitor */
+ BM_PLUGIN_ID_BATTERY /**< Battery */
+} bm_plugin_id_e;
+
+/*
+ * enum for feature data collection period
+ */
+typedef enum {
+ BM_DURATION_TYPE_1DAY = 0, /**< Set the period from a day ago to now */
+ BM_DURATION_TYPE_1WEEK /**< Set the period from a week ago to now */
+} bm_duration_type_e;
+
+/*
+ * enum for feature data type
+ */
+typedef enum {
+ BM_DATA_TYPE_BLE=0, /**< Bluetooth Low Energy */
+ BM_DATA_TYPE_WIFI, /**< Wi-Fi */
+ BM_DATA_TYPE_CPU, /**< CPU */
+ BM_DATA_TYPE_DISPLAY, /**< Display */
+ BM_DATA_TYPE_DEVICE_NETWORK, /**< Network */
+ BM_DATA_TYPE_GPS_SENSOR, /**< GPS */
+ BM_DATA_TYPE_HRM_SENSOR, /**< Heart Rate Monitor */
+ BM_DATA_TYPE_BATTERY /**< Battery */
+} bm_plugin_data_type_e;
+
+/*
+ * common structure for application time map.
+ */
+typedef struct {
+ char *app_id; /**< application id */
+ uint time; /**< total duration for which application as active */
+} app_time_map_st1;
+
+typedef struct {
+ char *app_id; /**< application id */
+ uint time; /**< total duration for which application as active */
+ uint rx; /**< Total Bytes received by the application during runtime */
+ uint tx; /**< Total Bytes transmitted by the application during runtime */
+} app_time_map_st2;
+
+/*
+ * structure for "display" feature data.
+ */
+typedef struct {
+ uint high; /**< total time in milliseconds during which brightness intensity was high */
+ uint low; /**< total time in milliseconds during which brightness intensity was low */
+ uint med; /**< total time in milliseconds during which brightness intensity was medium */
+ time_t start; /**< start time of feature data collection session */
+ time_t stop; /**< stop time of feature data collection session */
+ GSList *atm_list; /**< application time map('app_time_map_st1') list for all active applications between start & stop */
+ GSList *display_list; /**< list of nodes of 'bm_display_st' for next consecutive sessions */
+} bm_display_st;
+
+/*
+ * structure for "cpu" feature data.
+ */
+typedef struct {
+ uint cpuTicks; /**< CPU Usage during the session */
+ uint cpuTimeBackground; /**< Time spent in Background State average operating frequency will be used to calculate the power */
+ uint cpuTimeForeground; /**< Time spent in Foreground state average operating frequency will be used to calculate the power */
+ GSList *atm_list; /**< application time map('app_time_map_st1') list for all active applications between start & stop */
+ GSList *cpu_data_list; /**< list of nodes of 'bm_cpu_st' for next consecutive sessions */
+} bm_cpu_st;
+
+/*
+ * structure for "device_network" feature data.
+ */
+typedef struct {
+ uint time_level_0; /**< Total time in milliseconds during which signal_strength was on level 0 */
+ uint time_level_1; /**< Total time in milliseconds during which signal_strength was on level 1 */
+ uint time_level_2; /**< Total time in milliseconds during which signal_strength was on level 2 */
+ uint time_level_3; /**< Total time in milliseconds during which signal_strength was on level 3 */
+ uint time_level_4; /**< Total time in milliseconds during which signal_strength was on level 4 */
+ uint time_level_5; /**< Total time in milliseconds during which signal_strength was on level 5 */
+ uint time_level_6; /**< Total time in milliseconds during which signal_strength was on level 6 */
+ GSList *atm_list; /**< application time map('app_time_map_st2') list for all active applications between start & stop */
+ GSList *dn_data_list; /**< list of nodes of 'bm_device_network_st' for next consecutive sessions */
+} bm_device_network_st;
+
+/*
+ * structure for "Wi-Fi" feature data.
+ */
+typedef struct {
+ uint time_level_0; /**< Total time in milliseconds during which rssi was on level 0 */
+ uint time_level_1; /**< Total time in milliseconds during which rssi was on level 1 */
+ uint time_level_2; /**< Total time in milliseconds during which rssi was on level 2 */
+ uint time_level_3; /**< Total time in milliseconds during which rssi was on level 3 */
+ uint time_level_4; /**< Total time in milliseconds during which rssi was on level 4 */
+ time_t startTime; /**< start time of feature data collection session */
+ time_t endTime; /**< end time of feature data collection session */
+ uint scanTime; /**< Total time spent by the resource in (scan) mode during the session */
+ GSList *atm_list; /**< application time map('app_time_map_st2') list for all active applications between start & stop */
+ GSList *wifi_data_list; /**< list of nodes of 'bm_wifi_st' for next consecutive sessions */
+} bm_wifi_st;
+
+/*
+ * structure for "bluetooth" feature data.
+ */
+typedef struct {
+ uint scanTime; /**< Total time spent by the resource in (scan) mode during the session */
+ uint connectedTime; /**< Total time spent by the resource in (connected) mode during the session */
+ time_t startTime; /**< start time of feature data collection session */
+ time_t stopTime; /**< stop time of feature data collection session */
+ GSList *atm_list; /**< application time map('app_time_map_st2') list for all active applications between start & stop */
+ GSList *bt_data_list; /**< list of nodes of 'bm_bluetooth_st' for next consecutive sessions */
+} bm_bluetooth_st;
+
+/*
+ * structure for "gps" feature data.
+ */
+typedef struct {
+ time_t connStartTime; /**< start time of feature data collection session */
+ time_t connStopTime; /**< stop time of feature data collection session */
+ GSList *atm_list; /**< application time map('app_time_map_st1') list for all active applications between start & stop */
+ GSList *gps_data_list; /**< list of nodes of 'bm_gps_st' for next consecutive sessions */
+} bm_gps_st;
+
+/*
+ * structure for "hrm-sensor" feature data.
+ */
+typedef struct {
+ uint sensor_hub_wakeup_time; /**< wake-up time of sensor-hub */
+ uint sensor_hub_wakeup_count; /**< wake-up count of sensor-hub */
+ uint sensor_wakeup_time; /**< sensor wake-up time */
+ uint sensor_wakeup_count; /**< sensor wake-up count */
+ GSList *atm_list; /**< application time map('app_time_map_st1') list for all active applications between start & stop */
+ GSList *hrm_data_list; /**< list of nodes of 'bm_hrm_sensor_st' for next consecutive sessions */
+} bm_hrm_sensor_st;
+
+/*
+ * structure for "battery" feature data.
+ */
+typedef struct {
+ uint battery_percent; /**< Battery percent */
+ uint is_charging; /**< State of charging */
+} bm_battery_st;
+
+/* ========================================================================== */
+
+/*
+ * battery-monitor data handle
+ */
+typedef void *bm_data_h;
+
+/*
+ * Callback to be invoked when service is going OFF
+ *
+ * [Param] handle - handle through which service will provide data
+ * to battery-monitor service daemon.
+ *
+ * [Param] result - the result of callback operation
+ */
+typedef void (*bm_data_callback)(bm_plugin_error_e result, bm_data_h *handle);
+
+/*
+ * battery-monitor callback structure
+ */
+typedef struct {
+ bm_data_callback provide_feature_data;
+} bm_callbacks_st;
+
+/*
+ * structure for plugin API's
+ */
+typedef struct {
+ /*
+ * [Sync API] To initialize plugin
+ */
+ int (*init)(const bm_callbacks_st *callbacks);
+ /*
+ * [Sync API] To deinitialize plugin
+ */
+ int (*deinit)(void);
+ /*
+ * [Sync API] To get feature data from plugin
+ *
+ * [Param] handle - battery-monitor data handle through which plugin
+ * will provide data to the manager. This handle will be passed
+ * as reference, plugin will assign a valid object which will be
+ * set free by the manager; battery-monitor manager will typecast
+ * the object provided through handle for each plugin and will use
+ * it for further calculation.
+ *
+ * [Param] data_type - type of data like - BLE, WiFi, CPU etc.
+ */
+ int (*get_feature_data)(bm_data_h *handle, bm_plugin_data_type_e data_type);
+} bm_api_st;
+
+/*
+ * structure for plugin information
+ */
+typedef struct {
+ /*
+ * Respective "identifier" of Plugin
+ */
+ int id;
+ /*
+ * Respective "name" of Plugin
+ */
+ const char *name;
+ /*
+ * Respective "author" of Plugin
+ */
+ const char *author;
+ /*
+ * Respective "version" of Plugin
+ */
+ const char *version;
+ /*
+ * Plugin init function
+ */
+ int (*init)(bm_api_st **api);
+ /*
+ * Plugin de-init function
+ */
+ int (*deinit)(void);
+} bm_plugin_st;
+
+
+/*
+ * macro for adding plugin
+ */
+#define BM_PLUGIN_ADD(id, name, author, version, init, deinit) \
+ __attribute__ ((visibility("default"))) bm_plugin_st bm_plugin = { id, name, author, version, init, deinit };
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __BM_PLUGIN_INTERFACE_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2018 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 <stdio.h>
+#include <stdlib.h>
+#include <glib.h>
+#include <gio/gio.h>
+#include <sqlite3.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <app_manager.h>
+#include <runtime_info.h>
+
+#include "bm_plugin_interface.h"
+#include "bm_cpu_util.h"
+#include "bm_log.h"
+
+enum heart_cpu_status {
+ SERVICE = 0,
+ FOREG = 1,
+ BACKG = 2,
+};
+
+struct app_status {
+ pid_t pid;
+ time_t last_checkpoint; // Need to get usage from this time
+ time_t used_time; // utime + stime
+ enum heart_cpu_status last_status;
+};
+
+static struct timeval last_requested_time;
+
+static GDBusConnection *dbus_connection;
+static GHashTable *running_app_list; // Key(appid), Val(app_status)
+
+gint find_app_time(gconstpointer a, gconstpointer b)
+{
+ const char *appid = (const char *)b;
+ const app_time_map_st1 *app_time = (const app_time_map_st1 *)a;
+
+ return g_strcmp0(appid, app_time->app_id);
+}
+
+bool is_running_app(const char *appid)
+{
+ bool is_running = false;
+ int ret = app_manager_is_running(appid, &is_running);
+ if (ret != APP_MANAGER_ERROR_NONE) {
+ _E("app_manager_is_running failed (%d)", ret);
+ return false;
+ }
+
+ return is_running;
+}
+
+int deinit()
+{
+ ENTER;
+
+ if (dbus_connection) {
+ g_object_unref(dbus_connection);
+ dbus_connection = NULL;
+ }
+
+ if (running_app_list) {
+ g_hash_table_destroy(running_app_list);
+ running_app_list = NULL;
+ }
+
+ EXIT;
+ return BM_PLUGIN_ERROR_NONE;
+}
+
+int init()
+{
+ ENTER;
+
+ GError *g_err = NULL;
+
+ if (gettimeofday(&last_requested_time, NULL) != 0) {
+ _E("gettimeofday failed : %m");
+ goto failed;
+ }
+
+ dbus_connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &g_err);
+ if (!dbus_connection) {
+ _E("g_bus_get_sync failed : %s", g_err->message ? g_err->message : NULL);
+ g_error_free(g_err);
+ goto failed;
+ }
+
+ running_app_list = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+ if (!running_app_list) {
+ _E("g_hash_table_new_full failed");
+ goto failed;
+ }
+
+ EXIT;
+ return BM_PLUGIN_ERROR_NONE;
+
+failed:
+ deinit();
+
+ EXIT;
+ return BM_PLUGIN_ERROR_OUT_OF_MEMORY;
+}
+
+int get_feature_data(bm_data_h *handle, bm_plugin_data_type_e type)
+{
+ ENTER;
+
+ int ret;
+
+ bm_cpu_st *usage = NULL;
+
+ struct timeval tv;
+
+ GError *g_err = NULL;
+ GDBusMessage *msg_req, *msg_reply;
+
+ /* Sqlite */
+ sqlite3 *db;
+ sqlite3_stmt *stmt;
+ char query[128];
+
+ /* DB row */
+ unsigned int time;
+ const char *appid;
+ const char *data;
+ unsigned int utime, stime, pid, status;
+
+ /* App status */
+ struct app_status *app_status, *new_app_status;
+ int elapsed;
+ process_cpu_usage_s *cpu_usage;
+ GHashTableIter iter;
+ gpointer g_key, g_val;
+
+ /* App time map */
+ app_time_map_st1 *app_time_map;
+
+
+ /* Check argument */
+ if (!handle || type != BM_DATA_TYPE_CPU) {
+ _E("Invalid argument");
+ return BM_PLUGIN_ERROR_INVALID_PARAMETER;
+ }
+
+ /* Get current time */
+ ret = gettimeofday(&tv, NULL);
+ if (ret != 0) {
+ _E("gettimeofday failed : %m");
+
+ EXIT;
+ return BM_PLUGIN_ERROR_OUT_OF_MEMORY;
+ }
+
+ /* Request for resourced to update HEART-CPU DB */
+ msg_req = g_dbus_message_new_method_call(
+ "org.tizen.resourced",
+ "/Org/Tizen/ResourceD/Logging",
+ "org.tizen.resourced.logging",
+ "SyncCpuData"
+ );
+ if (!msg_req) {
+ if (g_err) {
+ _E("g_dbus_message_new_method_call failed : %s", g_err->message ? g_err->message : NULL);
+ g_error_free(g_err);
+ } else
+ _E("g_dbus_message_new_method_call failed");
+
+ EXIT;
+ return BM_PLUGIN_ERROR_NOT_SUPPORTED;
+ }
+
+ msg_reply = g_dbus_connection_send_message_with_reply_sync(dbus_connection, msg_req, G_DBUS_SEND_MESSAGE_FLAGS_NONE, -1, NULL, NULL, &g_err);
+ if (msg_reply)
+ g_object_unref(msg_reply);
+ else {
+ if (g_err) {
+ _W("g_dbus_connection_send_message_with_reply_sync failed : %s", g_err->message ? g_err->message : NULL);
+ g_error_free(g_err);
+ } else
+ _W("g_dbus_connection_send_message_with_reply_sync failed");
+ }
+
+ /* Open HEART-CPU DB */
+ ret = sqlite3_open("/opt/usr/home/owner/.applications/dbspace/.resourced-heart-default.db", &db);
+ if (ret != SQLITE_OK) {
+ _E("sqlite3_open failed (%d)", ret);
+
+ EXIT;
+ return BM_PLUGIN_ERROR_NO_DATA;
+ }
+
+ /* Make usage data structure */
+ usage = (bm_cpu_st *)calloc(1, sizeof(bm_cpu_st));
+ if (!usage) {
+ _E("calloc failed");
+
+ EXIT;
+ return BM_PLUGIN_ERROR_OUT_OF_MEMORY;
+ }
+
+ /* Read data from HEART-CPU DB */
+ _I("Gather CPU usage : %ld ~ %ld", last_requested_time.tv_sec, tv.tv_sec);
+ snprintf(query, 128, "SELECT time,appid,data FROM cpu WHERE time >= %ld", last_requested_time.tv_sec);
+ ret = sqlite3_prepare_v2(db, query, -1, &stmt, 0);
+ while (sqlite3_step(stmt) == SQLITE_ROW) {
+ time = sqlite3_column_int(stmt, 0);
+ appid = (const char *)sqlite3_column_text(stmt, 1);
+ data = (const char *)sqlite3_column_text(stmt, 2);
+ sscanf(data, "%u %u %u %u", &utime, &stime, &pid, &status);
+
+ //_D("time(%u), appid(%s), utime(%u), stime(%u), pid(%u), status(%u)", time, appid, utime, stime, pid, status);
+
+ /* Ignore terminated app */
+ if (!is_running_app(appid)) {
+ _D("%s is already terminated", appid);
+ g_hash_table_remove(running_app_list, appid);
+ continue;
+ }
+
+ app_status = g_hash_table_lookup(running_app_list, appid);
+
+ /* Insert newly launched app in the running app list */
+ if (!app_status) {
+ _D("%s is newly launched", appid);
+ new_app_status = malloc(sizeof(struct app_status));
+ new_app_status->pid = pid;
+ new_app_status->last_checkpoint = time;
+ new_app_status->used_time = utime + stime;
+ new_app_status->last_status = status;
+ g_hash_table_insert(running_app_list, g_strdup(appid), new_app_status);
+ continue;
+ }
+
+ /* Initialize restarted app */
+ if (app_status->pid != pid) {
+ _D("%s is restarted", appid);
+ app_status->pid = pid;
+ app_status->last_checkpoint = time;
+ app_status->used_time = utime + stime;
+ app_status->last_status = status;
+ continue;
+ }
+
+ /* Ignore CPU unused app */
+ elapsed = utime + stime - app_status->used_time;
+ if (elapsed <= 0) {
+ _D("%s doesn't use CPU. Ignore it", appid);
+ continue;
+ }
+
+ /* Accumulate used time */
+ _D("%s uses CPU (+%d)", appid, elapsed);
+ usage->cpuTicks += elapsed;
+ switch (app_status->last_status) {
+ case FOREG:
+ usage->cpuTimeForeground += elapsed;
+ break;
+ case BACKG:
+ case SERVICE:
+ usage->cpuTimeBackground += elapsed;
+ break;
+ }
+
+ /* Insert the app using CPU in the ATM list */
+ if (!g_slist_find_custom(usage->atm_list, appid, find_app_time)) {
+ app_time_map = malloc(sizeof(app_time_map_st1));
+ app_time_map->app_id = g_strdup(appid);
+ app_time_map->time = tv.tv_sec - app_status->last_checkpoint;
+ if (app_time_map->time <= 0)
+ app_time_map->time = 1;
+ usage->atm_list = g_slist_append(usage->atm_list, app_time_map);
+ }
+
+ /* Update app status */
+ app_status->used_time = utime + stime;
+ app_status->last_status = status;
+ }
+ sqlite3_finalize(stmt);
+ sqlite3_close(db);
+
+ /* Update all running apps with current value */
+ g_hash_table_iter_init(&iter, running_app_list);
+ while (g_hash_table_iter_next(&iter, &g_key, &g_val)) {
+ appid = (const char *)g_key;
+ app_status = (struct app_status *)g_val;
+
+ /* Ignore terminated app */
+ if (!is_running_app(appid)) {
+ _D("%s is already terminated", appid);
+ g_hash_table_iter_remove(&iter);
+ continue;
+ }
+
+ /* Get latest CPU time */
+ ret = runtime_info_get_process_cpu_usage(&app_status->pid, 1, &cpu_usage);
+ if (ret != RUNTIME_INFO_ERROR_NONE) {
+ _E("runtime_info_get_process_cpu_usage for %u failed(%d)", app_status->pid, ret);
+ continue;
+ }
+
+ app_status->last_checkpoint = tv.tv_sec;
+
+ /* Ignore CPU unused app */
+ elapsed = cpu_usage->utime + cpu_usage->stime - app_status->used_time;
+ if (elapsed <= 0) {
+ _D("%s doesn't use CPU. Ignore it", appid);
+ continue;
+ }
+
+ /* Update CPU time */
+ _D("%s uses CPU (+%d)", appid, elapsed);
+ usage->cpuTicks += elapsed;
+ switch (app_status->last_status) {
+ case FOREG:
+ usage->cpuTimeForeground += elapsed;
+ break;
+ case BACKG:
+ case SERVICE:
+ usage->cpuTimeBackground += elapsed;
+ break;
+ }
+
+ /* Insert the app using CPU in the ATM list */
+ if (!g_slist_find_custom(usage->atm_list, appid, find_app_time)) {
+ app_time_map = malloc(sizeof(app_time_map_st1));
+ app_time_map->app_id = g_strdup(appid);
+ app_time_map->time = tv.tv_sec - last_requested_time.tv_sec;
+ if (app_time_map->time <= 0)
+ app_time_map->time = 1;
+ usage->atm_list = g_slist_append(usage->atm_list, app_time_map);
+ }
+
+ app_status->used_time = cpu_usage->utime + cpu_usage->stime;
+
+ free(cpu_usage);
+ }
+
+ /* Update last requested time */
+ last_requested_time.tv_sec = tv.tv_sec;
+ last_requested_time.tv_usec = tv.tv_usec;
+
+ /* Return result */
+ *handle = usage;
+
+ _I("Succeed to get CPU usage");
+ EXIT;
+ return BM_PLUGIN_ERROR_NONE;
+}
+
+static bm_api_st cpu_api = {
+ .init = init,
+ .deinit = deinit,
+ .get_feature_data = get_feature_data
+};
+
+int plugin_init(bm_api_st **api)
+{
+ ENTER;
+
+ *api = &cpu_api;
+
+ EXIT;
+ return 0;
+}
+
+int plugin_deinit(void)
+{
+ ENTER;
+
+ EXIT;
+ return 0;
+}
+
+BM_PLUGIN_ADD(BM_PLUGIN_ID_CPU, NAME, AUTHOR, VERSION, plugin_init, plugin_deinit);
projects / platform / core / system / batterymonitor-plugins.git / commitdiff