- Modify API
- Rename get functions
- Require tracker type : no more only power lock's
- Modularization
- Each constructor adds their own tracker
- Iterate all trackers and run only for loaded trackers
Change-Id: Ifdcc55d04643b2d6694222fec5afd128e37d78f5
Signed-off-by: Kichan Kwon <k_c.kwon@samsung.com>
TRACKER_SERVICE_IOT = 1 << 5, /**< IoT services */
} tracker_service_e;
TRACKER_SERVICE_IOT = 1 << 5, /**< IoT services */
} tracker_service_e;
+typedef enum {
+ TRACKER_TYPE_POWER_LOCK = 0,
+ TRACKER_TYPE_MAX
+} tracker_type_e;
+
/**
* @brief Gets the reference count of the Power Lock operation
* @since_tizen 3.0
/**
* @brief Gets the reference count of the Power Lock operation
* @since_tizen 3.0
+ * @param[in] type Tracker type
* @param[out] count The reference count of the Power Lock operation
* @return @c 0 on success,
* otherwise a negative error value
* @param[out] count The reference count of the Power Lock operation
* @return @c 0 on success,
* otherwise a negative error value
* @retval #TRACKER_ERROR_INVALID_PARAMETER The input parameter is invalid
* @retval #TRACKER_ERROR_PERMISSION_DENIED No permission to use the API
*/
* @retval #TRACKER_ERROR_INVALID_PARAMETER The input parameter is invalid
* @retval #TRACKER_ERROR_PERMISSION_DENIED No permission to use the API
*/
-int tracker_get_power_lock_ref(int *count);
+int tracker_get_ref_counter(tracker_type_e type, int *count);
/**
* @brief Gets the total count of the Power Lock operation
* @since_tizen 3.0
/**
* @brief Gets the total count of the Power Lock operation
* @since_tizen 3.0
+ * @param[in] type Tracker type
* @param[out] count The total count of the Power Lock operation
* @return @c 0 on success,
* otherwise a negative error value
* @param[out] count The total count of the Power Lock operation
* @return @c 0 on success,
* otherwise a negative error value
* @retval #TRACKER_ERROR_INVALID_PARAMETER The input parameter is invalid
* @retval #TRACKER_ERROR_PERMISSION_DENIED No permission to use the API
*/
* @retval #TRACKER_ERROR_INVALID_PARAMETER The input parameter is invalid
* @retval #TRACKER_ERROR_PERMISSION_DENIED No permission to use the API
*/
-int tracker_get_power_lock_total(int *count);
+int tracker_get_tick(tracker_type_e type, int *count);
/**
* @brief Start tracking for information of services
/**
* @brief Start tracking for information of services
#define ARRAY_SIZE(name) (sizeof(name)/sizeof(name[0]))
#define ARRAY_SIZE(name) (sizeof(name)/sizeof(name[0]))
-int get_power_lock_ref(void);
-int get_power_lock_total(void);
+struct ops {
+ tracker_type_e type;
+ void (*ref)(tracker_service_e);
+ void (*unref)(tracker_service_e);
+ int (*get_ref_counter)(void);
+ int (*get_tick)(void);
+};
+
+struct counter {
+ tracker_service_e service;
+ unsigned int ref_counter;
+ int tick;
+};
+
+int power_lock_get_ref_counter(void);
+int power_lock_get_tick(void);
void power_lock_ref(tracker_service_e service);
void power_lock_unref(tracker_service_e service);
void power_lock_ref(tracker_service_e service);
void power_lock_unref(tracker_service_e service);
void start_service_iot(void);
void stop_service_iot(void);
void start_service_iot(void);
void stop_service_iot(void);
+/****************************************************************/
+
+struct ops *trackers[TRACKER_TYPE_MAX];
+
+#define REGISTER_TRACKER(name) \
+ static void __attribute__ ((constructor)) add_tracker(void) \
+ { \
+ trackers[(name)->type] = name; \
+ }
#endif /* __LIBTRACKER_TRACKER_PRIVATE_H__ */
#endif /* __LIBTRACKER_TRACKER_PRIVATE_H__ */
#define POWERLOCK_DEFAULT_REF 0
#define POWERLOCK_DEFAULT_COUNT 0
#define POWERLOCK_DEFAULT_REF 0
#define POWERLOCK_DEFAULT_COUNT 0
-struct powerlock_ref {
- tracker_service_e service;
- unsigned int ref;
- int total;
-} lock_refs[] = {
+static struct counter lock_counters[] = {
{ TRACKER_SERVICE_DOWNLOAD, POWERLOCK_DEFAULT_REF , POWERLOCK_DEFAULT_COUNT },
{ TRACKER_SERVICE_MEDIA, POWERLOCK_DEFAULT_REF , POWERLOCK_DEFAULT_COUNT },
{ TRACKER_SERVICE_NETWORK, POWERLOCK_DEFAULT_REF , POWERLOCK_DEFAULT_COUNT },
{ TRACKER_SERVICE_DOWNLOAD, POWERLOCK_DEFAULT_REF , POWERLOCK_DEFAULT_COUNT },
{ TRACKER_SERVICE_MEDIA, POWERLOCK_DEFAULT_REF , POWERLOCK_DEFAULT_COUNT },
{ TRACKER_SERVICE_NETWORK, POWERLOCK_DEFAULT_REF , POWERLOCK_DEFAULT_COUNT },
{ TRACKER_SERVICE_IOT, POWERLOCK_DEFAULT_REF , POWERLOCK_DEFAULT_COUNT },
};
{ TRACKER_SERVICE_IOT, POWERLOCK_DEFAULT_REF , POWERLOCK_DEFAULT_COUNT },
};
-#define COUNT_MAX (INT_MAX/ARRAY_SIZE(lock_refs))
+#define COUNT_MAX (INT_MAX/ARRAY_SIZE(lock_counters))
-int get_power_lock_ref(void)
+int power_lock_get_ref_counter(void)
- for (i = 0 ; i < ARRAY_SIZE(lock_refs) ; i++)
- sum += lock_refs[i].ref;
+ for (i = 0 ; i < ARRAY_SIZE(lock_counters) ; i++)
+ sum += lock_counters[i].ref_counter;
_I("Total reference count of pid(%d) is (%d)",
getpid(), sum);
_I("Total reference count of pid(%d) is (%d)",
getpid(), sum);
-int get_power_lock_total(void)
+int power_lock_get_tick(void)
- for (i = 0 ; i < ARRAY_SIZE(lock_refs) ; i++)
- sum += lock_refs[i].total;
+ for (i = 0 ; i < ARRAY_SIZE(lock_counters) ; i++)
+ sum += lock_counters[i].tick;
_I("Total lock count of pid(%d) is (%d)",
getpid(), sum);
_I("Total lock count of pid(%d) is (%d)",
getpid(), sum);
- for (i = 0 ; i < ARRAY_SIZE(lock_refs) ; i++) {
- if (lock_refs[i].service != service)
+ for (i = 0 ; i < ARRAY_SIZE(lock_counters) ; i++) {
+ if (lock_counters[i].service != service)
+ lock_counters[i].ref_counter++;
- if (lock_refs[i].total == COUNT_MAX)
- lock_refs[i].total = POWERLOCK_DEFAULT_COUNT;
+ if (lock_counters[i].tick == COUNT_MAX)
+ lock_counters[i].tick = POWERLOCK_DEFAULT_COUNT;
+ lock_counters[i].tick++;
_I("[%s] pid(%d) increases power lock ref count to (%d, %d)",
service_name_str(service, buf, sizeof(buf)),
_I("[%s] pid(%d) increases power lock ref count to (%d, %d)",
service_name_str(service, buf, sizeof(buf)),
- getpid(), lock_refs[i].ref, lock_refs[i].total);
+ getpid(), lock_counters[i].ref_counter, lock_counters[i].tick);
- for (i = 0 ; i < ARRAY_SIZE(lock_refs) ; i++) {
- if (lock_refs[i].service != service)
+ for (i = 0 ; i < ARRAY_SIZE(lock_counters) ; i++) {
+ if (lock_counters[i].service != service)
- if (lock_refs[i].ref > 0)
- lock_refs[i].ref--;
+ if (lock_counters[i].ref_counter > 0)
+ lock_counters[i].ref_counter--;
_I("[%s] pid(%d) decreases power lock ref count to (%d)",
service_name_str(service, buf, sizeof(buf)),
_I("[%s] pid(%d) decreases power lock ref count to (%d)",
service_name_str(service, buf, sizeof(buf)),
- getpid(), lock_refs[i].ref);
+ getpid(), lock_counters[i].ref_counter);
+
+static struct ops power_lock_ops = {
+ .type = TRACKER_TYPE_POWER_LOCK,
+ .ref = power_lock_ref,
+ .unref = power_lock_unref,
+ .get_ref_counter = power_lock_get_ref_counter,
+ .get_tick = power_lock_get_tick,
+};
+
+REGISTER_TRACKER(&power_lock_ops)
void start_service_download(void)
{
void start_service_download(void)
{
- power_lock_ref(TRACKER_SERVICE_DOWNLOAD);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->ref)
+ continue;
+ trackers[i]->ref(TRACKER_SERVICE_DOWNLOAD);
+ }
}
void stop_service_download(void)
{
}
void stop_service_download(void)
{
- power_lock_unref(TRACKER_SERVICE_DOWNLOAD);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->unref)
+ continue;
+ trackers[i]->unref(TRACKER_SERVICE_DOWNLOAD);
+ }
}
void start_service_media(void)
{
}
void start_service_media(void)
{
- power_lock_ref(TRACKER_SERVICE_MEDIA);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->ref)
+ continue;
+ trackers[i]->ref(TRACKER_SERVICE_MEDIA);
+ }
}
void stop_service_media(void)
{
}
void stop_service_media(void)
{
- power_lock_unref(TRACKER_SERVICE_MEDIA);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->unref)
+ continue;
+ trackers[i]->unref(TRACKER_SERVICE_MEDIA);
+ }
}
void start_service_network(void)
{
}
void start_service_network(void)
{
- power_lock_ref(TRACKER_SERVICE_NETWORK);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->ref)
+ continue;
+ trackers[i]->ref(TRACKER_SERVICE_NETWORK);
+ }
}
void stop_service_network(void)
{
}
void stop_service_network(void)
{
- power_lock_unref(TRACKER_SERVICE_NETWORK);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->unref)
+ continue;
+ trackers[i]->unref(TRACKER_SERVICE_NETWORK);
+ }
}
void start_service_location(void)
{
}
void start_service_location(void)
{
- power_lock_ref(TRACKER_SERVICE_LOCATION);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->ref)
+ continue;
+ trackers[i]->ref(TRACKER_SERVICE_LOCATION);
+ }
}
void stop_service_location(void)
{
}
void stop_service_location(void)
{
- power_lock_unref(TRACKER_SERVICE_LOCATION);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->unref)
+ continue;
+ trackers[i]->unref(TRACKER_SERVICE_LOCATION);
+ }
}
void start_service_sensor(void)
{
}
void start_service_sensor(void)
{
- power_lock_ref(TRACKER_SERVICE_SENSOR);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->ref)
+ continue;
+ trackers[i]->ref(TRACKER_SERVICE_SENSOR);
+ }
}
void stop_service_sensor(void)
{
}
void stop_service_sensor(void)
{
- power_lock_unref(TRACKER_SERVICE_SENSOR);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->unref)
+ continue;
+ trackers[i]->unref(TRACKER_SERVICE_SENSOR);
+ }
}
void start_service_iot(void)
{
}
void start_service_iot(void)
{
- power_lock_ref(TRACKER_SERVICE_IOT);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->ref)
+ continue;
+ trackers[i]->ref(TRACKER_SERVICE_IOT);
+ }
}
void stop_service_iot(void)
{
}
void stop_service_iot(void)
{
- power_lock_unref(TRACKER_SERVICE_IOT);
+ int i;
+ for (i = 0; i < TRACKER_TYPE_MAX; i++) {
+ if (!trackers[i] || !trackers[i]->unref)
+ continue;
+ trackers[i]->unref(TRACKER_SERVICE_IOT);
+ }
#include "tracker.h"
#include "tracker_private.h"
#include "tracker.h"
#include "tracker_private.h"
-API int tracker_get_power_lock_ref(int *cnt)
+API int tracker_get_ref_counter(tracker_type_e type, int *cnt)
- ref = get_power_lock_ref();
+ if (type < 0 || type >= TRACKER_TYPE_MAX || !trackers[type]) {
+ _E("Try to access not existed tracker %d", type);
+ return TRACKER_ERROR_INVALID_PARAMETER;
+ }
+
+ ref = trackers[type]->get_ref_counter();
if (ref < 0) {
_E("Failed to get power lock reference count(%d)", ref);
return ref;
if (ref < 0) {
_E("Failed to get power lock reference count(%d)", ref);
return ref;
return TRACKER_ERROR_NONE;
}
return TRACKER_ERROR_NONE;
}
-API int tracker_get_power_lock_total(int *cnt)
+API int tracker_get_tick(tracker_type_e type, int *cnt)
- count = get_power_lock_total();
+ if (type < 0 || type >= TRACKER_TYPE_MAX || !trackers[type]) {
+ _E("Try to access not existed tracker %d", type);
+ return TRACKER_ERROR_INVALID_PARAMETER;
+ }
+
+ count = trackers[type]->get_tick();
if (count < 0) {
_E("Failed to get power lock total count(%d)", count);
return count;
if (count < 0) {
_E("Failed to get power lock total count(%d)", count);
return count;