modify as Code convention

Signed-off-by: jongmun.woo <jongmun.woo@samsung.com>
Change-Id: I651167f99e54c0b5ad4ee0ee52401bd3660c7c75

diff --git a/packaging/capi-geofence-manager.spec b/packaging/capi-geofence-manager.spec
index df6842e7c22dc7323960b0490ca127c3a1ee7cb9..7f22277ad2a84d6d3abf00de44f98ea3640915b1 100644 (file)
--- a/packaging/capi-geofence-manager.spec
+++ b/packaging/capi-geofence-manager.spec
@@ -1,7 +1,7 @@
 #sbs-git:slp/api/geofence-manager capi-geofence-manager 0.1.0 d1ee09a32e8bc0e9ed48ece37c641a7393c086c5
 Name:       capi-geofence-manager
 Summary:    A Geofence Manager library in Tizen Native API
-Version:    0.3.2
+Version:    0.3.3
 Release:    1
 Group:      Location/Libraries
 License:    Apache-2.0

diff --git a/src/geofence_manager.c b/src/geofence_manager.c
index 0248643aa06a1943c3411f60bb373078d77bbdc3..93e6d76596f0d7342545ef0c413ac30859b2aa4c 100644 (file)
--- a/src/geofence_manager.c
+++ b/src/geofence_manager.c
@@ -103,30 +103,30 @@ void __handle_action(int place_id, int geofence_id, geofence_manager_error_e err
        }
 
        switch (action) {
-               case GEOFENCE_MANAGE_FENCE_STARTED: {
-                               geofence_info_s *fence_info = (geofence_info_s *)malloc(sizeof(geofence_info_s));
-                               if (fence_info == NULL)
-                                       break;
-                               fence_info->info = NULL;
-                               fence_info->state = GEOFENCE_STATE_UNCERTAIN;
-                               fence_info->last_updated_time = (g_get_real_time() / 1000000);
-                       g_hash_table_insert(fence_map, GINT_TO_POINTER(geofence_id), (gpointer)fence_info);
-                               /* Inserting the fence in the tracking list */
-                       tracking_list = g_list_append(tracking_list, GINT_TO_POINTER(geofence_id));
-                       }
-                       break;
-               case GEOFENCE_MANAGE_FENCE_STOPPED: {
-                       geofence_info_s *info = (geofence_info_s *)g_hash_table_lookup(fence_map, GINT_TO_POINTER(geofence_id));
-                               if (info != NULL) {
-                               g_hash_table_remove(fence_map, GINT_TO_POINTER(geofence_id));
-                                       free(info);
-                               }
-                               /* Removing the fence in the tracking list */
-                       tracking_list = g_list_remove(tracking_list, GINT_TO_POINTER(geofence_id));
+       case GEOFENCE_MANAGE_FENCE_STARTED: {
+                       geofence_info_s *fence_info = (geofence_info_s *)malloc(sizeof(geofence_info_s));
+                       if (fence_info == NULL)
+                               break;
+                       fence_info->info = NULL;
+                       fence_info->state = GEOFENCE_STATE_UNCERTAIN;
+                       fence_info->last_updated_time = (g_get_real_time() / 1000000);
+               g_hash_table_insert(fence_map, GINT_TO_POINTER(geofence_id), (gpointer)fence_info);
+                       /* Inserting the fence in the tracking list */
+               tracking_list = g_list_append(tracking_list, GINT_TO_POINTER(geofence_id));
+               }
+               break;
+       case GEOFENCE_MANAGE_FENCE_STOPPED: {
+               geofence_info_s *info = (geofence_info_s *)g_hash_table_lookup(fence_map, GINT_TO_POINTER(geofence_id));
+                       if (info != NULL) {
+                       g_hash_table_remove(fence_map, GINT_TO_POINTER(geofence_id));
+                               free(info);
                        }
-                       break;
-               default:
-                       break;
+                       /* Removing the fence in the tracking list */
+               tracking_list = g_list_remove(tracking_list, GINT_TO_POINTER(geofence_id));
+               }
+               break;
+       default:
+               break;
        }
 }
 
@@ -306,9 +306,8 @@ EXPORT_API int geofence_manager_create(geofence_manager_h *manager)
                        handle->sig_id[_GEOFENCE_SIGNAL_PROXIMITY] = g_signal_connect(handle->object, "geofence-proximity", G_CALLBACK(__cb_fence_proximity), handle);
 
                ret = geofence_ielement_create(GEOFENCE_IELEMENT(handle->object));
-               if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+               if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                        return __print_error_code(GEOFENCE_MANAGER_ERROR_EXCEPTION);
-               }
                /* Initialize the hashmaps to store the fence and place info */
                fence_map = g_hash_table_new(g_direct_hash, g_direct_equal);
                if (fence_map == NULL)
@@ -358,9 +357,8 @@ EXPORT_API int geofence_manager_destroy(geofence_manager_h manager)
        }
 
        ret = geofence_ielement_destroy(GEOFENCE_IELEMENT(handle->object));
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(GEOFENCE_MANAGER_ERROR_EXCEPTION);
-       }
 
        /* destroy the hashtables */
        g_hash_table_destroy(fence_map);
@@ -406,9 +404,8 @@ EXPORT_API int geofence_manager_start(geofence_manager_h manager, int geofence_i
        geofence_manager_s *handle = (geofence_manager_s *) manager;
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
-       if (__is_fence_started(geofence_id) == true) {
+       if (__is_fence_started(geofence_id) == true)
                return __print_error_code(GEOFENCE_MANAGER_ERROR_ALREADY_STARTED);
-       }
        ret = geofence_ielement_start(GEOFENCE_IELEMENT(handle->object), geofence_id);
        if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
@@ -434,11 +431,9 @@ EXPORT_API int geofence_manager_stop(geofence_manager_h manager, int geofence_id
                return __print_error_code(GEOFENCE_MANAGER_ERROR_EXCEPTION);
        }
        ret = geofence_ielement_stop(GEOFENCE_IELEMENT(handle->object), geofence_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) GEOFENCE_LOGD("Fail to stop. Error [%d]", ret);
-
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
-       }
+
        return GEOFENCE_MANAGER_ERROR_NONE;
 }
 
@@ -457,9 +452,8 @@ EXPORT_API int geofence_manager_add_fence(geofence_manager_h manager, geofence_h
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = geofence_ielement_add(GEOFENCE_IELEMENT(handle->object), (geofence_s *) params, geofence_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
-       }
 
        return GEOFENCE_MANAGER_ERROR_NONE;
 }
@@ -479,9 +473,8 @@ EXPORT_API int geofence_manager_add_place(geofence_manager_h manager, const char
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = geofence_ielement_add_place(GEOFENCE_IELEMENT(handle->object), place_name, place_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
-       }
 
        return GEOFENCE_MANAGER_ERROR_NONE;
 }
@@ -501,9 +494,8 @@ EXPORT_API int geofence_manager_update_place(geofence_manager_h manager, int pla
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = geofence_ielement_update_place(GEOFENCE_IELEMENT(handle->object), place_name, place_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
-       }
 
        return GEOFENCE_MANAGER_ERROR_NONE;
 }
@@ -522,9 +514,9 @@ EXPORT_API int geofence_manager_remove_fence(geofence_manager_h manager, int geo
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = geofence_ielement_remove(GEOFENCE_IELEMENT(handle->object), geofence_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
-       }
+
        return GEOFENCE_MANAGER_ERROR_NONE;
 }
 
@@ -542,9 +534,8 @@ EXPORT_API int geofence_manager_remove_place(geofence_manager_h manager, int pla
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = geofence_ielement_remove_place(GEOFENCE_IELEMENT(handle->object), place_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
-       }
 
        return GEOFENCE_MANAGER_ERROR_NONE;
 }
@@ -564,9 +555,9 @@ EXPORT_API int geofence_manager_get_place_name(geofence_manager_h manager, int p
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = geofence_ielement_get_place_name(GEOFENCE_IELEMENT(handle->object), place_id, place_name);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
-       }
+
        return GEOFENCE_MANAGER_ERROR_NONE;
 }
 
@@ -660,9 +651,8 @@ EXPORT_API int geofence_manager_foreach_geofence_list(geofence_manager_h manager
        geofence_s *params = NULL;
 
        ret = geofence_ielement_get_fence_list(GEOFENCE_IELEMENT(handle->object), -1, &fence_amount, &fence_ids, &params);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
-       }
 
        if (fence_amount == 0) {
                if (callback)
@@ -678,9 +668,8 @@ EXPORT_API int geofence_manager_foreach_geofence_list(geofence_manager_h manager
        }
 
        int iterations = fence_amount;
-       while (iterations-- > 0) {
+       while (iterations-- > 0)
                geofence_parameter_free((geofence_s *)(params++));
-       }
 
        g_slice_free1(sizeof(int)*fence_amount, fence_ids);
 
@@ -708,9 +697,8 @@ EXPORT_API int geofence_manager_foreach_place_geofence_list(geofence_manager_h m
 
        GEOFENCE_LOGD("place_id: %d", place_id);
        ret = geofence_ielement_get_fence_list(GEOFENCE_IELEMENT(handle->object), place_id, &fence_amount, &fence_ids, &params);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
-       }
 
        if (fence_amount == 0) {
                callback(0, NULL, 0, 0, user_data);
@@ -722,9 +710,8 @@ EXPORT_API int geofence_manager_foreach_place_geofence_list(geofence_manager_h m
                GEOFENCE_LOGD("Fence id: %d, lat: %lf, lon: %lf, rad: %d, address: %s, bssid: %s, ssid: %s", fence_ids[i], params[i].latitude, params[i].longitude, params[i].radius, params[i].address, params[i].bssid, params[i].ssid);
        }
        int iterations = fence_amount;
-       while (iterations-- > 0) {
+       while (iterations-- > 0)
                geofence_parameter_free((geofence_s *)(params++));
-       }
 
        g_slice_free1(sizeof(int)*fence_amount, fence_ids);
 
@@ -749,23 +736,21 @@ EXPORT_API int geofence_manager_foreach_place_list(geofence_manager_h manager, g
        place_s *params = NULL;
 
        ret = geofence_ielement_get_place_list(GEOFENCE_IELEMENT(handle->object), &place_amount, &place_ids, &params);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                return __print_error_code(ret);
-       }
+
        if (place_amount == 0) {
                callback(0, NULL, 0, 0, user_data);
                return GEOFENCE_MANAGER_ERROR_NONE;
        }
 
        int i = 0;
-       for (i = 0; i < place_amount; i++) {
+       for (i = 0; i < place_amount; i++)
                callback(place_ids[i], ((const place_s *)(params + i))->place_name, (i + 1), place_amount, user_data);
-       }
 
        int iterations = place_amount;
-       while (iterations-- > 0) {
+       while (iterations-- > 0)
                g_slice_free(place_s, (params++));
-       }
 
        g_slice_free1(sizeof(int)*place_amount, place_ids);
 

diff --git a/src/manager/geofence-ielement.c b/src/manager/geofence-ielement.c
index 0ef83be97e824f5f849011eb7c17085156bb60c2..3ea3893b66cd3bd4f1fab2a98bb999a8a7875856 100644 (file)
--- a/src/manager/geofence-ielement.c
+++ b/src/manager/geofence-ielement.c
@@ -17,7 +17,7 @@
 #include "geofence-ielement.h"
 
 static void _glib_log(const gchar *log_domain, GLogLevelFlags log_level,
-                      const gchar *msg, gpointer user_data)
+                                               const gchar *msg, gpointer user_data)
 {
 
        GEOFENCE_LOGD("GLIB[%d] : %s", log_level, msg);
@@ -33,14 +33,14 @@ GType geofence_ielement_get_type(void)
        if (!iface_type) {
                static const GTypeInfo info = {
                        sizeof(GeofenceIElementInterface),      /* class_size */
-                       NULL,                           /* base_init */
-                       NULL                            /* base_finalize */
+                       NULL,                           /* base_init */
+                       NULL                            /* base_finalize */
                };
 
-               iface_type = g_type_register_static(G_TYPE_INTERFACE,   /* parent-type */
-                                                   "GeofenceIElement", /* type name */
-                                                   &info,                              /* info */
-                                                   0);                                 /* flags */
+               iface_type = g_type_register_static(G_TYPE_INTERFACE,   /* parent-type */
+                                                                                       "GeofenceIElement",     /* type name */
+                                                                                       &info,                          /* info */
+                                                                                       0);                                     /* flags */
        }
 
        return iface_type;

diff --git a/src/manager/geofence-ielement.h b/src/manager/geofence-ielement.h
index b4dc845be5b7ed8502f403e267ad2f8f18dbebe6..f477deea253485d3793f3556be28dd3b8daa1f11 100644 (file)
--- a/src/manager/geofence-ielement.h
+++ b/src/manager/geofence-ielement.h
@@ -34,10 +34,10 @@ enum {
     LAST_SIGNAL
 };
 
-#define GEOFENCE_TYPE_IELEMENT                  (geofence_ielement_get_type ())
-#define GEOFENCE_IELEMENT(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEOFENCE_TYPE_IELEMENT, GeofenceIElement))
-#define GEOFENCE_IS_IELEMENT(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEOFENCE_TYPE_IELEMENT))
-#define GEOFENCE_IELEMENT_GET_INTERFACE(obj)    (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEOFENCE_TYPE_IELEMENT, GeofenceIElementInterface))
+#define GEOFENCE_TYPE_IELEMENT                  (geofence_ielement_get_type())
+#define GEOFENCE_IELEMENT(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), GEOFENCE_TYPE_IELEMENT, GeofenceIElement))
+#define GEOFENCE_IS_IELEMENT(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), GEOFENCE_TYPE_IELEMENT))
+#define GEOFENCE_IELEMENT_GET_INTERFACE(obj)    (G_TYPE_INSTANCE_GET_INTERFACE((obj), GEOFENCE_TYPE_IELEMENT, GeofenceIElementInterface))
 
 typedef struct _GeofenceIElement          GeofenceIElement;
 typedef struct _GeofenceIElementInterface GeofenceIElementInterface;

diff --git a/src/manager/geofence-internal.c b/src/manager/geofence-internal.c
index c18e5c5c477c0e9faf0b693a4e769a62bc72e8a4..0c39d96e5fd84278c515a0c4d6e36d4cafd38a37 100644 (file)
--- a/src/manager/geofence-internal.c
+++ b/src/manager/geofence-internal.c
@@ -28,14 +28,14 @@
 
 typedef struct _GeofenceInternalPrivate {
        GeofenceInternalMod             *mod;
-       GMutex                  mutex;
-       geofence_s              *params;
+       GMutex                                  mutex;
+       geofence_s                              *params;
 } GeofenceInternalPrivate;
 
 enum {
-    PROP_0,
-    PROP_GEOFENCE_PARAMS,
-    PROP_MAX
+       PROP_0,
+       PROP_GEOFENCE_PARAMS,
+       PROP_MAX
 };
 
 static guint32 signals[LAST_SIGNAL] = { 0, };
@@ -48,8 +48,8 @@ static void geofence_ielement_interface_init(GeofenceIElementInterface *iface);
 
 
 G_DEFINE_TYPE_WITH_CODE(GeofenceInternal, geofence_internal, G_TYPE_OBJECT,
-                        G_IMPLEMENT_INTERFACE(GEOFENCE_TYPE_IELEMENT,
-                                              geofence_ielement_interface_init));
+                                               G_IMPLEMENT_INTERFACE(GEOFENCE_TYPE_IELEMENT,
+                                               geofence_ielement_interface_init));
 
 /*
 static void geofence_parameter_set_property (GObject *object,
@@ -104,9 +104,9 @@ static void geofence_internal_finalize(GObject *gobject)
 }
 
 static void geofence_internal_get_property(GObject *object,
-                                           guint property_id,
-                                           GValue *value,
-                                           GParamSpec *pspec)
+                                                                                       guint property_id,
+                                                                                       GValue *value,
+                                                                                       GParamSpec *pspec)
 {
        GEOFENCE_LOGD("geofence_internal_get_property");
        GeofenceInternalPrivate *priv = GET_PRIVATE(object);
@@ -115,12 +115,12 @@ static void geofence_internal_get_property(GObject *object,
        g_return_if_fail(priv->mod->handler);
 
        switch (property_id) {
-               case PROP_GEOFENCE_PARAMS:
-                       g_value_set_boxed(value, priv->params);
-                       break;
-               default:
-                       G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
-                       break;
+       case PROP_GEOFENCE_PARAMS:
+               g_value_set_boxed(value, priv->params);
+               break;
+       default:
+               G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+               break;
        }
 }
 
@@ -152,11 +152,11 @@ void geofence_proximity_signaling(GeofenceObject *obj, guint32 signals[LAST_SIGN
 }
 
 void geofence_event_signaling(GeofenceObject *obj,
-                              guint32 signals[LAST_SIGNAL],
-                              guint place_id,
-                              guint fence_id,
-                              guint error,
-                              guint state)
+                                                               guint32 signals[LAST_SIGNAL],
+                                                               guint place_id,
+                                                               guint fence_id,
+                                                               guint error,
+                                                               guint state)
 {
        GEOFENCE_LOGD("geofence_event_signaling");
        g_return_if_fail(obj);
@@ -208,9 +208,9 @@ static int geofence_internal_create(GeofenceInternal *self)
 
        if (gIsCreated == 0) {
                ret = priv->mod->ops.create(priv->mod->handler, _state_cb, _proximity_cb, _geofence_event_cb, self);
-               if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+               if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                        GEOFENCE_LOGE("Fail to create. Error[%d]", ret);
-               }
+
                gIsCreated = 1;
        }
 
@@ -229,13 +229,11 @@ static int geofence_internal_destroy(GeofenceInternal *self)
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = priv->mod->ops.destroy(priv->mod->handler);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Fail to destroy. Error[%d]", ret);
-       }
 
-       if (gIsCreated == 1) {
+       if (gIsCreated == 1)
                gIsCreated = 0;
-       }
 
        return ret;
 }
@@ -251,9 +249,9 @@ static int geofence_internal_enable_service(GeofenceInternal *self, int geofence
 
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
        ret = priv->mod->ops.enable_service(priv->mod->handler, geofence_id, enable);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Fail to enable the geofence. Error[%d]", ret);
-       }
+
        return ret;
 }
 
@@ -269,9 +267,9 @@ static int geofence_internal_start(GeofenceInternal *self, int geofence_id)
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = priv->mod->ops.start_geofence(priv->mod->handler, geofence_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Fail to start geofence. Error[%d]", ret);
-       }
+
        return ret;
 }
 
@@ -287,9 +285,9 @@ static int geofence_internal_stop(GeofenceInternal *self, int geofence_id)
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = priv->mod->ops.stop_geofence(priv->mod->handler, geofence_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Failed to stop. Error[%d]", ret);
-       }
+
        return ret;
 }
 
@@ -314,18 +312,16 @@ static int geofence_internal_add(GeofenceInternal *self, geofence_s *params, int
 
        if (priv->params->type == GEOFENCE_TYPE_GEOPOINT) {
                ret = priv->mod->ops.add_geopoint(priv->mod->handler, priv->params->place_id, priv->params->latitude, priv->params->longitude, priv->params->radius, priv->params->address, geofence_id);
-               if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+               if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                        GEOFENCE_LOGE("Fail to add geofence. Error[%d]", ret);
-               } else {
+               else
                        GEOFENCE_LOGE("Success to add geofence. Error[%d]", ret);
-               }
        } else {
                ret = priv->mod->ops.add_bssid(priv->mod->handler, priv->params->place_id, priv->params->bssid, priv->params->ssid, priv->params->type, geofence_id);
-               if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+               if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                        GEOFENCE_LOGE("Fail to add geofence. Error[%d]", ret);
-               } else {
+               else
                        GEOFENCE_LOGE("Success to add geofence. Error[%d]", ret);
-               }
        }
 
        return ret;
@@ -343,9 +339,9 @@ static int geofence_internal_remove(GeofenceInternal *self, int geofence_id)
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = priv->mod->ops.remove_geofence(priv->mod->handler, geofence_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Failed to remove geofence. Error[%d]", ret);
-       }
+
        return ret;
 }
 
@@ -361,9 +357,9 @@ static int geofence_internal_get_list(GeofenceInternal *self, int place_id, int
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = priv->mod->ops.get_geofences(priv->mod->handler, place_id, fence_amount, fence_ids, params);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Failed to get list. Error[%d]", ret);
-       }
+
        return ret;
 }
 
@@ -379,11 +375,10 @@ static int geofence_internal_add_place(GeofenceInternal *self, const char *place
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = priv->mod->ops.add_place(priv->mod->handler, place_name, place_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Failed to add place. Error[%d]", ret);
-       } else {
+       else
                GEOFENCE_LOGE("Success to add place. Error[%d]", ret);
-       }
 
        return ret;
 }
@@ -402,11 +397,10 @@ static int geofence_internal_update_place(GeofenceInternal *self, const char *pl
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = priv->mod->ops.update_place(priv->mod->handler, place_id, place_name);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Fail to update place. Error[%d]", ret);
-       } else {
+       else
                GEOFENCE_LOGE("Success to update place. Error[%d]", ret);
-       }
 
        return ret;
 }
@@ -424,11 +418,11 @@ static int geofence_internal_remove_place(GeofenceInternal *self, int place_id)
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = priv->mod->ops.remove_place(priv->mod->handler, place_id);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Failed to remove place. Error[%d]", ret);
-       } else {
+       else
                GEOFENCE_LOGE("Success to remove place. Error[%d]", ret);
-       }
+
        return ret;
 }
 
@@ -444,11 +438,11 @@ static int geofence_internal_get_place_name(GeofenceInternal *self, int place_id
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = priv->mod->ops.get_place_name(priv->mod->handler, place_id, place_name);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Failed to get the place name. Error[%d]", ret);
-       } else {
+       else
                GEOFENCE_LOGE("Success to get the place name. Error[%d]", ret);
-       }
+
        return ret;
 }
 
@@ -465,9 +459,9 @@ static int geofence_internal_get_place_list(GeofenceInternal *self, int *place_a
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
 
        ret = priv->mod->ops.get_places(priv->mod->handler, place_amount, place_ids, params);
-       if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+       if (ret != GEOFENCE_MANAGER_ERROR_NONE)
                GEOFENCE_LOGE("Failed to get place list. Error[%d]", ret);
-       }
+
        return ret;
 }
 
@@ -516,24 +510,24 @@ static void geofence_internal_class_init(GeofenceInternalClass *klass)
        g_type_class_add_private(klass, sizeof(GeofenceInternalPrivate));
 
        signals[ZONE_IN] = g_signal_new("zone-in",
-                                       G_TYPE_FROM_CLASS(klass),
-                                       G_SIGNAL_RUN_FIRST |
-                                       G_SIGNAL_NO_RECURSE,
-                                       G_STRUCT_OFFSET(GeofenceInternalClass, zone_in),
-                                       NULL, NULL,
-                                       geofence_VOID__UINT,
-                                       G_TYPE_NONE, 1,
-                                       G_TYPE_UINT);
+                                                                       G_TYPE_FROM_CLASS(klass),
+                                                                       G_SIGNAL_RUN_FIRST |
+                                                                       G_SIGNAL_NO_RECURSE,
+                                                                       G_STRUCT_OFFSET(GeofenceInternalClass, zone_in),
+                                                                       NULL, NULL,
+                                                                       geofence_VOID__UINT,
+                                                                       G_TYPE_NONE, 1,
+                                                                       G_TYPE_UINT);
 
        signals[ZONE_OUT] = g_signal_new("zone-out",
-                                        G_TYPE_FROM_CLASS(klass),
-                                        G_SIGNAL_RUN_FIRST |
-                                        G_SIGNAL_NO_RECURSE,
-                                        G_STRUCT_OFFSET(GeofenceInternalClass, zone_out),
-                                        NULL, NULL,
-                                        geofence_VOID__UINT,
-                                        G_TYPE_NONE, 1,
-                                        G_TYPE_UINT);
+                                                                       G_TYPE_FROM_CLASS(klass),
+                                                                       G_SIGNAL_RUN_FIRST |
+                                                                       G_SIGNAL_NO_RECURSE,
+                                                                       G_STRUCT_OFFSET(GeofenceInternalClass, zone_out),
+                                                                       NULL, NULL,
+                                                                       geofence_VOID__UINT,
+                                                                       G_TYPE_NONE, 1,
+                                                                       G_TYPE_UINT);
 
        signals[GEOFENCE_PROXIMITY] = g_signal_new("geofence-proximity",
                                                G_TYPE_FROM_CLASS(klass),
@@ -548,26 +542,26 @@ static void geofence_internal_class_init(GeofenceInternalClass *klass)
                                                G_TYPE_UINT);
 
        signals[GEOFENCE_EVENT] = g_signal_new("geofence-event",
-                                              G_TYPE_FROM_CLASS(klass),
-                                              G_SIGNAL_RUN_FIRST |
-                                              G_SIGNAL_NO_RECURSE,
-                                              G_STRUCT_OFFSET(GeofenceInternalClass, geofence_event),
-                                              NULL, NULL,
-                                              g_cclosure_marshal_generic,
-                                              G_TYPE_NONE, 4,
-                                              G_TYPE_UINT,
-                                              G_TYPE_UINT,
-                                              G_TYPE_UINT,
-                                              G_TYPE_UINT);
+                                                                                       G_TYPE_FROM_CLASS(klass),
+                                                                                       G_SIGNAL_RUN_FIRST |
+                                                                                       G_SIGNAL_NO_RECURSE,
+                                                                                       G_STRUCT_OFFSET(GeofenceInternalClass, geofence_event),
+                                                                                       NULL, NULL,
+                                                                                       g_cclosure_marshal_generic,
+                                                                                       G_TYPE_NONE, 4,
+                                                                                       G_TYPE_UINT,
+                                                                                       G_TYPE_UINT,
+                                                                                       G_TYPE_UINT,
+                                                                                       G_TYPE_UINT);
 
        properties[PROP_GEOFENCE_PARAMS] = g_param_spec_boxed("geofence-parameter",
-                                                             "geofence parameter prop",
-                                                             "geofence parameter data",
-                                                             GEOFENCE_PRAMETER,
-                                                             G_PARAM_READABLE);
+                                                                                                               "geofence parameter prop",
+                                                                                                               "geofence parameter data",
+                                                                                                               GEOFENCE_PRAMETER,
+                                                                                                               G_PARAM_READABLE);
 
        g_object_class_install_properties(gobject_class,
-                                         PROP_MAX,
-                                         properties);
+                                                                               PROP_MAX,
+                                                                               properties);
 
 }

diff --git a/src/manager/geofence-internal.h b/src/manager/geofence-internal.h
index 3b479dedaaf9b4aece3278a101f65277e8d43296..18bdda4cec67a8d153040e8221ff8f47dd164e3a 100644 (file)
--- a/src/manager/geofence-internal.h
+++ b/src/manager/geofence-internal.h
@@ -25,12 +25,12 @@
 
 G_BEGIN_DECLS
 
-#define GEOFENCE_TYPE_INTERNAL                                 (geofence_internal_get_type ())
-#define GEOFENCE_INTERNAL(obj)                                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEOFENCE_TYPE_INTERNAL, GeofenceInternal))
-#define GEOFENCE_IS_INTERNAL(obj)                              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEOFENCE_TYPE_INTERNAL))
-#define GEOFENCE_INTERNAL_CLASS(klass)                 (G_TYPE_CHECK_CLASS_CAST ((klass), GEOFENCE_TYPE_INTERNAL, GeofenceInternalClass))
-#define GEOFENCE_IS_INTERNAL_CLASS(klass)              (G_TYPE_CHECK_CLASS_TYPE ((klass), GEOFENCE_TYPE_INTERNAL))
-#define GEOFENCE_INTERNAL_GET_CLASS(obj)               (G_TYPE_INSTANCE_GET_CLASS ((obj), GEOFENCE_TYPE_INTERNAL, GeofenceInternalClass))
+#define GEOFENCE_TYPE_INTERNAL                                 (geofence_internal_get_type())
+#define GEOFENCE_INTERNAL(obj)                                 (G_TYPE_CHECK_INSTANCE_CAST((obj), GEOFENCE_TYPE_INTERNAL, GeofenceInternal))
+#define GEOFENCE_IS_INTERNAL(obj)                              (G_TYPE_CHECK_INSTANCE_TYPE((obj), GEOFENCE_TYPE_INTERNAL))
+#define GEOFENCE_INTERNAL_CLASS(klass)                 (G_TYPE_CHECK_CLASS_CAST((klass), GEOFENCE_TYPE_INTERNAL, GeofenceInternalClass))
+#define GEOFENCE_IS_INTERNAL_CLASS(klass)              (G_TYPE_CHECK_CLASS_TYPE((klass), GEOFENCE_TYPE_INTERNAL))
+#define GEOFENCE_INTERNAL_GET_CLASS(obj)               (G_TYPE_INSTANCE_GET_CLASS((obj), GEOFENCE_TYPE_INTERNAL, GeofenceInternalClass))
 
 typedef struct _GeofenceInternal       GeofenceInternal;
 typedef struct _GeofenceInternalClass  GeofenceInternalClass;
@@ -42,10 +42,10 @@ struct _GeofenceInternal {
 struct _GeofenceInternalClass {
        GObjectClass parent_class;
 
-       void (* zone_in)(guint geofence_id);
-       void (* zone_out)(guint geofence_id);
-       void (* geofence_proximity)(guint geofence_id, guint proximity_state, guint provider);
-       void (* geofence_event)(guint place_id, guint geofence_id, guint error, guint state);
+       void (*zone_in)(guint geofence_id);
+       void (*zone_out)(guint geofence_id);
+       void (*geofence_proximity)(guint geofence_id, guint proximity_state, guint provider);
+       void (*geofence_event)(guint place_id, guint geofence_id, guint error, guint state);
 };
 
 /*typedef void (*service_status_cb) (int status, void *user_data); */

diff --git a/src/manager/geofence-log.c b/src/manager/geofence-log.c
index 4041c0aac60bc3f2ea9c465fcff88e51b16bfaac..5a1c877f9cfb8ad2daac8b3fef989e2e397f356e 100644 (file)
--- a/src/manager/geofence-log.c
+++ b/src/manager/geofence-log.c
@@ -25,53 +25,53 @@ int __print_error_code(int code)
        int ret = GEOFENCE_MANAGER_ERROR_NONE;
        char *msg = "GEOFENCE_MANAGER_ERROR_NONE";
        switch (code) {
-               case GEOFENCE_MANAGER_ERROR_NONE:
-                       ret = GEOFENCE_MANAGER_ERROR_NONE;
-                       msg = "GEOFENCE_MANAGER_ERROR_NONE";
-                       break;
-               case GEOFENCE_MANAGER_ERROR_PERMISSION_DENIED:
-                       ret = GEOFENCE_MANAGER_ERROR_PERMISSION_DENIED;
-                       msg = "GEOFENCE_MANAGER_ERROR_PERMISSION_DENIED";
-                       break;
-               case GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED:
-                       ret = GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED;
-                       msg = "GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED";
-                       break;
-               case GEOFENCE_MANAGER_ERROR_INVALID_ID:
-                       ret = GEOFENCE_MANAGER_ERROR_INVALID_ID;
-                       msg = "GEOFENCE_MANAGER_ERROR_INVALID_ID";
-                       break;
-               case GEOFENCE_MANAGER_ERROR_EXCEPTION:
-                       ret = GEOFENCE_MANAGER_ERROR_EXCEPTION;
-                       msg = "GEOFENCE_MANAGER_ERROR_EXCEPTION";
-                       break;
-               case GEOFENCE_MANAGER_ERROR_ALREADY_STARTED:
-                       ret = GEOFENCE_MANAGER_ERROR_ALREADY_STARTED;
-                       msg = "GEOFENCE_MANAGER_ERROR_ALREADY_STARTED";
-                       break;
-               case GEOFENCE_MANAGER_ERROR_TOO_MANY_GEOFENCE:
-                       ret = GEOFENCE_MANAGER_ERROR_TOO_MANY_GEOFENCE;
-                       msg = "GEOFENCE_MANAGER_ERROR_TOO_MANY_GEOFENCE";
-                       break;
-               case GEOFENCE_MANAGER_ERROR_IPC:
-                       ret = GEOFENCE_MANAGER_ERROR_IPC;
-                       msg = "GEOFENCE_MANAGER_ERROR_IPC";
-                       break;
-               case GEOFENCE_MANAGER_ERROR_DATABASE:
-                       ret = GEOFENCE_MANAGER_ERROR_DATABASE;
-                       msg = "GEOFENCE_MANAGER_ERROR_DATABASE";
-                       break;
-               case GEOFENCE_MANAGER_ERROR_PLACE_ACCESS_DENIED:
-                       ret = GEOFENCE_MANAGER_ERROR_PLACE_ACCESS_DENIED;
-                       msg = "GEOFENCE_MANAGER_ERROR_PLACE_ACCESS_DENIED";
-                       break;
-               case GEOFENCE_MANAGER_ERROR_GEOFENCE_ACCESS_DENIED:
-                       ret = GEOFENCE_MANAGER_ERROR_GEOFENCE_ACCESS_DENIED;
-                       msg = "GEOFENCE_MANAGER_ERROR_GEOFENCE_ACCESS_DENIED";
-                       break;
-               default:
-                       msg = "GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED";
-                       ret = GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED;
+       case GEOFENCE_MANAGER_ERROR_NONE:
+               ret = GEOFENCE_MANAGER_ERROR_NONE;
+               msg = "GEOFENCE_MANAGER_ERROR_NONE";
+               break;
+       case GEOFENCE_MANAGER_ERROR_PERMISSION_DENIED:
+               ret = GEOFENCE_MANAGER_ERROR_PERMISSION_DENIED;
+               msg = "GEOFENCE_MANAGER_ERROR_PERMISSION_DENIED";
+               break;
+       case GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED:
+               ret = GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED;
+               msg = "GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED";
+               break;
+       case GEOFENCE_MANAGER_ERROR_INVALID_ID:
+               ret = GEOFENCE_MANAGER_ERROR_INVALID_ID;
+               msg = "GEOFENCE_MANAGER_ERROR_INVALID_ID";
+               break;
+       case GEOFENCE_MANAGER_ERROR_EXCEPTION:
+               ret = GEOFENCE_MANAGER_ERROR_EXCEPTION;
+               msg = "GEOFENCE_MANAGER_ERROR_EXCEPTION";
+               break;
+       case GEOFENCE_MANAGER_ERROR_ALREADY_STARTED:
+               ret = GEOFENCE_MANAGER_ERROR_ALREADY_STARTED;
+               msg = "GEOFENCE_MANAGER_ERROR_ALREADY_STARTED";
+               break;
+       case GEOFENCE_MANAGER_ERROR_TOO_MANY_GEOFENCE:
+               ret = GEOFENCE_MANAGER_ERROR_TOO_MANY_GEOFENCE;
+               msg = "GEOFENCE_MANAGER_ERROR_TOO_MANY_GEOFENCE";
+               break;
+       case GEOFENCE_MANAGER_ERROR_IPC:
+               ret = GEOFENCE_MANAGER_ERROR_IPC;
+               msg = "GEOFENCE_MANAGER_ERROR_IPC";
+               break;
+       case GEOFENCE_MANAGER_ERROR_DATABASE:
+               ret = GEOFENCE_MANAGER_ERROR_DATABASE;
+               msg = "GEOFENCE_MANAGER_ERROR_DATABASE";
+               break;
+       case GEOFENCE_MANAGER_ERROR_PLACE_ACCESS_DENIED:
+               ret = GEOFENCE_MANAGER_ERROR_PLACE_ACCESS_DENIED;
+               msg = "GEOFENCE_MANAGER_ERROR_PLACE_ACCESS_DENIED";
+               break;
+       case GEOFENCE_MANAGER_ERROR_GEOFENCE_ACCESS_DENIED:
+               ret = GEOFENCE_MANAGER_ERROR_GEOFENCE_ACCESS_DENIED;
+               msg = "GEOFENCE_MANAGER_ERROR_GEOFENCE_ACCESS_DENIED";
+               break;
+       default:
+               msg = "GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED";
+               ret = GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED;
        }
        GEOFENCE_LOGE("ERROR : %s(0x%08x)", msg, ret);
        return ret;

diff --git a/src/manager/geofence-log.h b/src/manager/geofence-log.h
index f43bb679a59b5dd37ffd8270f90a59a878ed3f63..9eadd214f297f469d9b0111b019af5607e36936e 100644 (file)
--- a/src/manager/geofence-log.h
+++ b/src/manager/geofence-log.h
@@ -27,10 +27,10 @@
 * Internal Macros
 */
 
-#define GEOFENCE_LOGD(fmt,args...) LOGD(fmt, ##args)
-#define GEOFENCE_LOGW(fmt,args...) LOGW(fmt, ##args)
-#define GEOFENCE_LOGI(fmt,args...) LOGI(fmt, ##args)
-#define GEOFENCE_LOGE(fmt,args...) LOGE(fmt, ##args)
+#define GEOFENCE_LOGD(fmt, args...) LOGD(fmt, ##args)
+#define GEOFENCE_LOGW(fmt, args...) LOGW(fmt, ##args)
+#define GEOFENCE_LOGI(fmt, args...) LOGI(fmt, ##args)
+#define GEOFENCE_LOGE(fmt, args...) LOGE(fmt, ##args)
 
 #define GEOFENCE_CHECK_CONDITION(condition, error, msg)        \
        do { \
@@ -55,7 +55,7 @@ extern "C" {
 
 
 #define GEOFENCE_NULL_ARG_CHECK(arg)   \
-       GEOFENCE_CHECK_CONDITION((arg != NULL),GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER,"GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER") \
+       GEOFENCE_CHECK_CONDITION((arg != NULL), GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER, "GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER") \
         
 int __print_error_code(int code);
 

diff --git a/src/manager/geofence-param.h b/src/manager/geofence-param.h
index 3899d85ff04f76b40a2576292452206b4d51b41c..4e030f2e10a3aea24e1e57998a9e54018a536722 100644 (file)
--- a/src/manager/geofence-param.h
+++ b/src/manager/geofence-param.h
@@ -21,7 +21,7 @@
 G_BEGIN_DECLS
 
 GType geofence_parameter_get_type(void);
-#define GEOFENCE_PRAMETER (geofence_parameter_get_type ())
+#define GEOFENCE_PRAMETER (geofence_parameter_get_type())
 
 geofence_s *geofence_parameter_new(gint place_id, guint type, gdouble latitude, gdouble longitude, guint radius, const gchar *address, const gchar *bssid, const gchar *ssid);
 geofence_s *geofence_parameter_copy(const geofence_s *params);

diff --git a/src/manager/geofence.c b/src/manager/geofence.c
index 01b239900694a1e4b2602e4cefd83bccf3073eac..0c576ecf5a97dd6edfd7a5f2c79f1dbf1a86132f 100644 (file)
--- a/src/manager/geofence.c
+++ b/src/manager/geofence.c
@@ -66,9 +66,8 @@ gboolean geofence_is_supported(void)
 
        gboolean supported = FALSE;
 
-       if (module_is_supported("geofence")) {
+       if (module_is_supported("geofence"))
                supported = TRUE;
-       }
 
        return supported;
 }

diff --git a/src/manager/module-internal.c b/src/manager/module-internal.c
index 4e28050fcac17ca0d2f6ce468564753b2027f920..c8f8e1be6d28d9a1ef4ae2b47dbece72a9d027f3 100644 (file)
--- a/src/manager/module-internal.c
+++ b/src/manager/module-internal.c
@@ -131,9 +131,8 @@ static void mod_free(gpointer mod, const char *module_name)
 
        if (0 == g_strcmp0(module_name, "geofence")) {
                GeofenceInternalMod *_mod = (GeofenceInternalMod *) mod;
-               if (_mod->shutdown && _mod->handler) {
+               if (_mod->shutdown && _mod->handler)
                        _mod->shutdown(_mod->handler);
-               }
                _mod->handler = NULL;
                _mod->init = NULL;
                _mod->shutdown = NULL;
@@ -149,9 +148,8 @@ static gboolean mod_is_supported(const char *module_name)
 {
        GMod *gmod = NULL;
        gmod = gmod_new(module_name, FALSE);
-       if (!gmod) {
+       if (!gmod)
                return FALSE;
-       }
        gmod_free(gmod);
 
        return TRUE;
@@ -181,15 +179,15 @@ GeofenceInternalMod *module_new(const char *module_name)
        char name[256];
 
        gpointer mod = NULL;
-       if (0 >= g_snprintf(name, 256, "%s", module_name)) {
+       if (0 >= g_snprintf(name, 256, "%s", module_name))
                GEOFENCE_LOGW("module name(%s) is wrong", name);
-       }
        mod = mod_new(name);
-       if (mod) {
+
+       if (mod)
                GEOFENCE_LOGW("module (%s) open success", name);
-       } else {
+       else
                GEOFENCE_LOGW("module (%s) open failed", name);
-       }
+
        return mod;
 }
 
@@ -205,11 +203,10 @@ gboolean module_is_supported(const char *module_name)
        char name[256] = { 0, };
 
        for (index = -1; index < MAX_MODULE_INDEX; index++) {
-               if (index >= 0) {
+               if (index >= 0)
                        g_snprintf(name, 256, "%s%d", module_name, index);
-               } else {
+               else
                        g_snprintf(name, 256, "%s", module_name);
-               }
 
                ret = mod_is_supported(name);
                if (ret == TRUE) {