Add logs for debugging

This patch adds logs and changes the log level for debugging.

Change-Id: I73ce4116b5c7e88bf23b3307c5d8cbee667a3f73
Signed-off-by: Hwankyu Jhun <h.jhun@samsung.com>

diff --git a/preference/stub.cc b/preference/stub.cc
index dbdafd38fca928f6e75dd32102ce48580033e44c..b29a8ec6d7067a890d023766deadf59df618b58f 100644 (file)
--- a/preference/stub.cc
+++ b/preference/stub.cc
@@ -129,11 +129,11 @@ extern "C" API int preference_set_int(const char* key, int intval) {
 
   int ret = pref->SetInt(key, intval);
   if (ret < 0) {
-    _E("Failed to set integer value");
+    _E("Failed to set integer value. key=%s", key);
     return PREFERENCE_ERROR_IO_ERROR;
   }
 
-  SECURE_LOGD("key(%s), value(%d)", key, intval);
+  SECURE_LOGI("key(%s), value(%d)", key, intval);
   return PREFERENCE_ERROR_NONE;
 }
 
@@ -150,11 +150,11 @@ extern "C" API int preference_set_boolean(const char* key, bool boolval) {
 
   int ret = pref->SetBoolean(key, boolval);
   if (ret < 0) {
-    _E("Failed to set boolean value");
+    _E("Failed to set boolean value. key=%s", key);
     return PREFERENCE_ERROR_IO_ERROR;
   }
 
-  SECURE_LOGD("key(%s), value(%d)", key, boolval);
+  SECURE_LOGI("key(%s), value(%d)", key, boolval);
   return PREFERENCE_ERROR_NONE;
 }
 
@@ -171,12 +171,11 @@ extern "C" API int preference_set_double(const char* key, double dblval) {
 
   int ret = pref->SetDouble(key, dblval);
   if (ret < 0) {
-    _E("Failed to set double value");
+    _E("Failed to set double value. key=%s", key);
     return PREFERENCE_ERROR_IO_ERROR;
   }
 
-  SECURE_LOGD("key(%s), value(%lf)", key, dblval);
-
+  SECURE_LOGI("key(%s), value(%lf)", key, dblval);
   return PREFERENCE_ERROR_NONE;
 }
 
@@ -193,11 +192,11 @@ extern "C" API int preference_set_string(const char* key, const char* strval) {
 
   int ret = pref->SetString(key, strval);
   if (ret < 0) {
-    _E("Failed to set string value");
+    _E("Failed to set string value. key=%s", key);
     return PREFERENCE_ERROR_IO_ERROR;
   }
 
-  SECURE_LOGD("key(%s), value(%s)", key, strval);
+  SECURE_LOGI("key(%s), value(%s)", key, strval);
   return PREFERENCE_ERROR_NONE;
 }
 
@@ -212,16 +211,19 @@ extern "C" API int preference_get_int(const char* key, int* intval) {
     return PREFERENCE_ERROR_IO_ERROR;
   }
 
-  if (!pref->IsExisting(key))
+  if (!pref->IsExisting(key)) {
+    _E("key(%s) does not exist", key);
     return PREFERENCE_ERROR_NO_KEY;
+  }
 
   try {
     *intval = pref->GetInt(key);
   } catch (const preference::internal::Exception& e) {
+    _E("Failed to get value. error(%s)", e.what());
     return e.GetErrorCode();
   }
 
-  SECURE_LOGD("key(%s), value(%d)", key, *intval);
+  SECURE_LOGI("key(%s), value(%d)", key, *intval);
   return get_last_result();
 }
 
@@ -236,16 +238,19 @@ extern "C" API int preference_get_boolean(const char* key, bool* boolval) {
     return PREFERENCE_ERROR_IO_ERROR;
   }
 
-  if (!pref->IsExisting(key))
+  if (!pref->IsExisting(key)) {
+    _E("key(%s) does not exist", key);
     return PREFERENCE_ERROR_NO_KEY;
+  }
 
   try {
     *boolval = pref->GetBoolean(key);
   } catch (const preference::internal::Exception& e) {
+    _E("Failed to get value. error(%s)", e.what());
     return e.GetErrorCode();
   }
 
-  SECURE_LOGD("key(%s), value(%d)", key, *boolval);
+  SECURE_LOGI("key(%s), value(%d)", key, *boolval);
   return get_last_result();
 }
 
@@ -260,16 +265,19 @@ extern "C" API int preference_get_double(const char* key, double* dblval) {
     return PREFERENCE_ERROR_IO_ERROR;
   }
 
-  if (!pref->IsExisting(key))
+  if (!pref->IsExisting(key)) {
+    _E("key(%s) does not exist", key);
     return PREFERENCE_ERROR_NO_KEY;
+  }
 
   try {
     *dblval = pref->GetDouble(key);
   } catch (const preference::internal::Exception& e) {
+    _E("Failed to get value. error(%s)", e.what());
     return e.GetErrorCode();
   }
 
-  SECURE_LOGD("key(%s), value(%lf)", key, *dblval);
+  SECURE_LOGI("key(%s), value(%lf)", key, *dblval);
   return get_last_result();
 }
 
@@ -284,16 +292,19 @@ extern "C" API int preference_get_string(const char* key, char** value) {
     return PREFERENCE_ERROR_IO_ERROR;
   }
 
-  if (!pref->IsExisting(key))
+  if (!pref->IsExisting(key)) {
+    _E("key(%s) does not exist", key);
     return PREFERENCE_ERROR_NO_KEY;
+  }
 
   try {
     *value = strdup(pref->GetString(key).c_str());
   } catch (const preference::internal::Exception& e) {
+    _E("Failed to get value. error(%s)", e.what());
     return e.GetErrorCode();
   }
 
-  SECURE_LOGD("key(%s), value(%s)", key, *value);
+  SECURE_LOGI("key(%s), value(%s)", key, *value);
   return get_last_result();
 }
 
@@ -319,7 +330,7 @@ extern "C" API int preference_remove(const char* key) {
     return PREFERENCE_ERROR_IO_ERROR;
   }
 
-  SECURE_LOGD("key(%s)", key);
+  SECURE_LOGW("key(%s)", key);
   return PREFERENCE_ERROR_NONE;
 }
 
@@ -335,7 +346,7 @@ extern "C" API int preference_is_existing(const char* key, bool* exist) {
   }
 
   *exist = pref->IsExisting(key);
-  SECURE_LOGD("key(%s), existence(%d)", key, *exist);
+  SECURE_LOGI("key(%s), existence(%d)", key, *exist);
   return PREFERENCE_ERROR_NONE;
 }
 
@@ -351,7 +362,7 @@ extern "C" API int preference_remove_all(void) {
     return PREFERENCE_ERROR_IO_ERROR;
   }
 
-  SECURE_LOGD("RemoveAll");
+  SECURE_LOGI("RemoveAll");
   return PREFERENCE_ERROR_NONE;
 }
 
@@ -378,7 +389,7 @@ extern "C" API int preference_set_changed_cb(const char* key,
     return PREFERENCE_ERROR_OUT_OF_MEMORY;
   }
 
-  SECURE_LOGD("key(%s)", key);
+  SECURE_LOGI("key(%s)", key);
   return PREFERENCE_ERROR_NONE;
 }
 
@@ -404,7 +415,7 @@ extern "C" API int preference_unset_changed_cb(const char* key) {
     return PREFERENCE_ERROR_NO_KEY;
   }
 
-  SECURE_LOGD("key(%s)", key);
+  SECURE_LOGI("key(%s)", key);
   return PREFERENCE_ERROR_NONE;
 }
 
@@ -442,11 +453,12 @@ extern "C" API int preference_get_type(const char* key,
   }
 
   if (!pref->IsExisting(key)) {
+    _E("key(%s) does not exist", key);
     *type = PREFERENCE_TYPE_NONE;
     return PREFERENCE_ERROR_NONE;
   }
 
   *type = static_cast<preference_type_e>(pref->GetType(key));
-  SECURE_LOGD("key(%s), type(%d)", key, *type);
+  SECURE_LOGI("key(%s), type(%d)", key, *type);
   return PREFERENCE_ERROR_NONE;
 }