* 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.
+ * limitations under the License.
*/
#endif
/**
- * @addtogroup CAPI_PREFERENCE_MODULE
+ * @file app_preference.h
+ */
+
+/**
+ * @addtogroup CAPI_PREFERENCE_MODULE
* @{
*/
/**
- * @brief Enumerations of error code for Preference.
+ * @brief Enumeration for Preference Error.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum
{
PREFERENCE_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
PREFERENCE_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
PREFERENCE_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
- PREFERENCE_ERROR_NO_KEY = TIZEN_ERROR_KEY_NOT_AVAILABLE, /**< Required key not available */
+ PREFERENCE_ERROR_NO_KEY = TIZEN_ERROR_APPLICATION | 0x30, /**< Required key not available */
PREFERENCE_ERROR_IO_ERROR = TIZEN_ERROR_IO_ERROR , /**< Internal I/O Error */
} preference_error_e;
/**
- * @brief Called when the given key's value in the preference changes.
+ * @brief Called when the given key's value in the preference changes.
*
- * @details When the @a key is added or removed, this callback function is skipped. (only update can be handled)
+ * @details When the @a key is added or removed, this callback function is skipped(only update can be handled).
*
- * @param [in] key The name of the key in the preference
- * @param [in] user_data The user data passed from the callback registration function
- * @pre This function is invoked when the value of the key is overwritten after you register this callback using preference_set_changed_cb()
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key in the preference
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre This function is invoked when the value of the key is overwritten after you register this callback using preference_set_changed_cb().
* @see preference_set_changed_cb()
* @see preference_unset_changed_cb()
* @see preference_set_boolean()
/**
-* @brief Called to get key string once for each key-value pair in the preference.
-*
-* @remarks You should not free @a key returned by this function.
-*
-* @param [in] key The key of the value added to the preference
-* @param [in] value The value associated with the key
-* @param [in] user_data The user data passed from the foreach function
-* @return @c true to continue with the next iteration of the loop, \n @c false to break out of the loop.
-* @pre preference_foreach_item() will invoke this callback function.
-* @see preference_foreach_item()
-*/
+ * @brief Called to get key string, once for each key-value pair in the preference.
+ *
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @remarks You should not free the @a key returned by this function.
+ *
+ * @param[in] key The key of the value added to the preference
+ * @param[in] value The value associated with the key
+ * @param[in] user_data The user data passed from the foreach function
+ * @return @c true to continue with the next iteration of the loop,
+ * otherwise @c false to break out of the loop
+ * @pre preference_foreach_item() will invoke this callback function.
+ * @see preference_foreach_item()
+ */
typedef bool (*preference_item_cb)(const char *key, void *user_data);
/**
* @brief Sets an integer value in the preference.
*
- * @param [in] key The name of the key to modify
- * @param [in] value The new @c int value for the given key
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to modify
+ * @param[in] value The new @c int value for the given key
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
* @see preference_get_int()
- *
*/
int preference_set_int(const char *key, int value);
/**
- * @brief Gets a integer value from the preference.
+ * @brief Gets an integer value from the preference.
*
- * @param [in] key The name of the key to retrieve
- * @param [out] value The @c int value for the given key
- * @return 0 on success, otherwise a negative error value.
- * @retval #PREFERENCE_ERROR_NONE Successful
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to retrieve
+ * @param[out] value The @c int value for the given key
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ * @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_NO_KEY Required key not available
* @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
/**
* @brief Sets a double value in the preference.
*
- * @param [in] key The name of the key to modify
- * @param [in] value The new @c double value associated with given key
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to modify
+ * @param[in] value The new @c double value associated with the given key
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
* @see preference_get_double()
- *
*/
int preference_set_double(const char *key, double value);
/**
* @brief Gets a double value from the preference.
*
- * @param [in] key The name of the key to retrieve
- * @param [out] value The @c double value associated with given key
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to retrieve
+ * @param[out] value The @c double value associated with the given key
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_NO_KEY Required key not available
* @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
* @see preference_set_double()
- *
*/
int preference_get_double(const char *key, double *value);
* @brief Sets a string value in the preference.
*
* @details It makes a deep copy of the added string value.
- *
- * @param [in] key The name of the key to modify
- * @param [in] value The new @c string value associated with given key
- * @return 0 on success, otherwise a negative error value.
+ *
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to modify
+ * @param[in] value The new @c string value associated with the given key
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
* @see preference_get_string()
- *
*/
int preference_set_string(const char *key, const char *value);
/**
* @brief Gets a string value from the preference.
*
- * @remarks @a value must be released with free() by you.
- * @param [in] key The name of the key to retrieve
- * @param [out] value The @c string value associated with given key
- * @return 0 on success, otherwise a negative error value.
- * @retval #PREFERENCE_ERROR_NONE Successful
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @remarks @a value must be released using free().
+ * @param[in] key The name of the key to retrieve
+ * @param[out] value The @c string value associated with the given key
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ * @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_OUT_OF_MEMORY Out of memory
* @retval #PREFERENCE_ERROR_NO_KEY Required key not available
/**
* @brief Sets a boolean value in the preference.
*
- * @param [in] key The name of the key to modify
- * @param [in] value The new boolean @c value associated with given key
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to modify
+ * @param[in] value The new @c boolean value associated with the given key
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
+ * @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
* @see preference_get_boolean()
*/
int preference_set_boolean(const char *key, bool value);
/**
* @brief Gets a boolean value from the preference.
*
- * @param [in] key The name of the key to retrieve
- * @param [out] value The boolean @c value associated with given key
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to retrieve
+ * @param[out] value The @c boolean value associated with the given key
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_NO_KEY Required key not available
/**
* @brief Removes any value with the given @a key from the preference.
*
- * @param [in] key The name of the key to remove
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to remove
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
- * @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
- *
*/
int preference_remove(const char *key);
/**
- * @brief Checks whether if the given @a key exists in the preference.
+ * @brief Checks whether the given @a key exists in the preference.
*
- * @param [in] key The name of the key to check
- * @param [out] existing @c true if the @a key exists in the preference, otherwise @c false
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to check
+ * @param[out] existing If @c true the @a key exists in the preference,
+ * otherwise @c false
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
/**
* @brief Removes all key-value pairs from the preference.
*
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
* @see preference_remove()
/**
* @brief Registers a callback function to be invoked when value of the given key in the preference changes.
*
- * @param [in] key The name of the key to monitor
- * @param [in] callback The callback function to register
- * @param [in] user_data The user data to be passed to the callback function
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to monitor
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_OUT_OF_MEMORY Out of memory
/**
* @brief Unregisters the callback function.
*
- * @param [in] key The name of the key to monitor
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] key The name of the key to monitor
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
/**
* @brief Retrieves all key-value pairs in the preference by invoking the callback function.
*
- * @param [in] callback The callback function to get key value once for each key-value pair in the preference
- * @param [in] user_data The user data to be passed to the callback function
- * @return 0 on success, otherwise a negative error value.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] callback The callback function to get key value once for each key-value pair in the preference
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success,
+ * otherwise a negative error value
* @retval #PREFERENCE_ERROR_NONE Successful
* @retval #PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #PREFERENCE_ERROR_IO_ERROR Internal I/O Error
* 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,
+ * 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 <unistd.h>
+#include <limits.h>
#include <string.h>
-#include <sqlite3.h>
-
-#include <app_private.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/xattr.h>
+#include <ctype.h>
+#include <string.h>
+#include <execinfo.h>
#include <app_preference.h>
-#include <app_preference_private.h>
+#include <app_preference_internal.h>
+#include <app_common.h>
-#include <dlog.h>
-
-#ifdef LOG_TAG
-#undef LOG_TAG
+#ifndef API
+#define API __attribute__ ((visibility("default")))
#endif
-#define LOG_TAG "CAPI_APPFW_APPLICATION_PREFERENCE"
-#define DBG_MODE (1)
+#define PREFERENCE_ERROR_RETRY_CNT 7
+#define PREFERENCE_ERROR_RETRY_SLEEP_UTIME 10000
+
+#define DELIMITER 29
+
+static int g_posix_errno;
+static int g_preference_errno;
+static char *g_pref_dir_path = NULL;
-static sqlite3 *pref_db;
-static bool is_update_hook_registered;
-static pref_changed_cb_node_t *head;
-static void _finish(void *data)
+enum preference_op_t {
+ PREFERENCE_OP_GET = 0,
+ PREFERENCE_OP_SET = 1
+};
+
+#ifdef PREFERENCE_TIMECHECK
+double correction, startT;
+
+double set_start_time(void)
{
- if (pref_db != NULL) {
- sqlite3_close(pref_db);
- pref_db = NULL;
- }
+ struct timeval tv;
+ double curtime;
+
+ gettimeofday(&tv, NULL);
+ curtime = tv.tv_sec * 1000 + (double)tv.tv_usec / 1000;
+ return curtime;
}
-static int _busy_handler(void *pData, int count)
+double exec_time(double start)
{
- if (count < 5) {
- LOGD("Busy Handler Called! : PID(%d) / CNT(%d)\n",
- getpid(), count+1);
- usleep((count+1)*100000);
- return 1;
- } else {
- LOGD("Busy Handler will be returned SQLITE_BUSY error : PID(%d)\n",
- getpid());
- return 0;
- }
+ double end = set_start_time();
+ return (end - start - correction);
}
-static int _initialize(void)
+int init_time(void)
{
- char *data_path;
- char db_path[TIZEN_PATH_MAX];
- int ret;
- char *errmsg;
+ double temp_t;
+ temp_t = set_start_time();
+ correction = exec_time(temp_t);
- data_path = app_get_data_path();
- if (data_path == NULL) {
- LOGE("IO_ERROR(0x%08x) : fail to get data directory",
- PREFERENCE_ERROR_IO_ERROR);
- return PREFERENCE_ERROR_IO_ERROR;
- }
- snprintf(db_path, sizeof(db_path), "%s/%s", data_path, PREF_DB_NAME);
- free(data_path);
+ return 0;
+}
+#endif
- ret = sqlite3_open_v2(db_path, &pref_db, SQLITE_OPEN_CREATE, NULL);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to open db(%s)",
- PREFERENCE_ERROR_IO_ERROR, sqlite3_errmsg(pref_db));
- _finish(NULL);
- return PREFERENCE_ERROR_IO_ERROR;
+char* _preference_get_pref_dir_path()
+{
+ char *app_data_path = NULL;
+
+ if (!g_pref_dir_path)
+ {
+ g_pref_dir_path = (char *)malloc(PREFERENCE_KEY_PATH_LEN + 1);
+ if ((app_data_path = app_get_data_path()) == NULL)
+ {
+ ERR("IO_ERROR(0x%08x) : fail to get data directory", PREFERENCE_ERROR_IO_ERROR);
+ free(g_pref_dir_path);
+ g_pref_dir_path = NULL;
+ return NULL;
+ }
+ snprintf(g_pref_dir_path, PREFERENCE_KEY_PATH_LEN, "%s%s", app_data_path, PREF_DIR);
+ INFO("pref_dir_path: %s", g_pref_dir_path);
+ free(app_data_path);
}
+ return g_pref_dir_path;
+}
- ret = sqlite3_busy_handler(pref_db, _busy_handler, NULL);
- if (ret != SQLITE_OK) {
- LOGW("IO_ERROR(0x%08x) : fail to register busy handler(%s)\n",
- PREFERENCE_ERROR_IO_ERROR, sqlite3_errmsg(pref_db));
- }
+int _preference_keynode_set_keyname(keynode_t *keynode, const char *keyname)
+{
+ if (keynode->keyname) free(keynode->keyname);
+ keynode->keyname = strndup(keyname, PREFERENCE_KEY_PATH_LEN);
+ retvm_if(keynode->keyname == NULL, PREFERENCE_ERROR_IO_ERROR, "strndup Fails");
+ return PREFERENCE_ERROR_NONE;
+}
- ret = sqlite3_exec(pref_db,
- "CREATE TABLE IF NOT EXISTS pref ( pref_key TEXT PRIMARY KEY, pref_type TEXT, pref_data TEXT)",
- NULL, NULL, &errmsg);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to create db table(%s)",
- PREFERENCE_ERROR_IO_ERROR, errmsg);
- sqlite3_free(errmsg);
- _finish(NULL);
- return PREFERENCE_ERROR_IO_ERROR;
- }
+static inline void _preference_keynode_set_value_int(keynode_t *keynode, const int value)
+{
+ keynode->type = PREFERENCE_TYPE_INT;
+ keynode->value.i = value;
+}
- app_finalizer_add(_finish, NULL);
+static inline void _preference_keynode_set_value_boolean(keynode_t *keynode, const int value)
+{
+ keynode->type = PREFERENCE_TYPE_BOOLEAN;
+ keynode->value.b = !!value;
+}
- return PREFERENCE_ERROR_NONE;
+static inline void _preference_keynode_set_value_double(keynode_t *keynode, const double value)
+{
+ keynode->type = PREFERENCE_TYPE_DOUBLE;
+ keynode->value.d = value;
}
-static int _prepare_and_bind_stmt(char *buf, const char *type,
- const char *data, const char *key, sqlite3_stmt **stmt)
+static inline void _preference_keynode_set_value_string(keynode_t *keynode, const char *value)
{
- int ret;
+ keynode->type = PREFERENCE_TYPE_STRING;
+ keynode->value.s = strdup(value);
+}
- ret = sqlite3_prepare(pref_db, buf, -1, stmt, NULL);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to prepare query (%d/%s)",
- PREFERENCE_ERROR_IO_ERROR,
- sqlite3_extended_errcode(pref_db),
- sqlite3_errmsg(pref_db));
- return PREFERENCE_ERROR_IO_ERROR;
- }
+inline keynode_t *_preference_keynode_new(void)
+{
+ keynode_t *keynode;
+ keynode = calloc(1, sizeof(keynode_t));
- ret = sqlite3_bind_text(*stmt, 1, type, -1, SQLITE_STATIC);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to bind(1) query (%d/%s)",
- PREFERENCE_ERROR_IO_ERROR,
- sqlite3_extended_errcode(pref_db),
- sqlite3_errmsg(pref_db));
- sqlite3_finalize(*stmt);
- return PREFERENCE_ERROR_IO_ERROR;
- }
- ret = sqlite3_bind_text(*stmt, 2, data, -1, SQLITE_STATIC);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to bind(2) query (%d/%s)",
- PREFERENCE_ERROR_IO_ERROR,
- sqlite3_extended_errcode(pref_db),
- sqlite3_errmsg(pref_db));
- sqlite3_finalize(*stmt);
- return PREFERENCE_ERROR_IO_ERROR;
+ return keynode;
+}
+
+inline void _preference_keynode_free(keynode_t *keynode)
+{
+ if(keynode) {
+ if (keynode->keyname)
+ free(keynode->keyname);
+ if (keynode->type == PREFERENCE_TYPE_STRING && keynode->value.s)
+ free(keynode->value.s);
+ free(keynode);
}
- ret = sqlite3_bind_text(*stmt, 3, key, -1, SQLITE_STATIC);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to bind(3) query (%d/%s)",
- PREFERENCE_ERROR_IO_ERROR,
- sqlite3_extended_errcode(pref_db),
- sqlite3_errmsg(pref_db));
- sqlite3_finalize(*stmt);
- return PREFERENCE_ERROR_IO_ERROR;
+}
+
+int _preference_get_key_name(const char *keyfile, char *keyname)
+{
+ char convert_key[PREFERENCE_KEY_PATH_LEN] = {0,};
+ char *chrptr = NULL;
+
+ strncpy(convert_key, keyfile, strlen(keyfile));
+
+ chrptr = strchr((const char*)convert_key, DELIMITER);
+ if(chrptr) {
+ chrptr = strchr((const char*)convert_key, DELIMITER);
+ while(chrptr) {
+ convert_key[chrptr-convert_key] = '/';
+ chrptr = strchr((const char*)chrptr+1, DELIMITER);
+ }
}
+ snprintf(keyname, PREFERENCE_KEY_PATH_LEN, "%s", (const char*)convert_key);
return PREFERENCE_ERROR_NONE;
}
-static int _write_data(const char *key, const char *type, const char *data)
+
+int _preference_get_key_path(const char *keyname, char *path)
{
- int ret;
- bool exist = false;
- sqlite3_stmt *stmt;
- char buf[BUF_LEN];
+ const char *key = NULL;
- if (key == NULL || key[0] == '\0' || data == NULL) {
- LOGE("INVALID_PARAMETER(0x%08x)",
- PREFERENCE_ERROR_INVALID_PARAMETER);
- return PREFERENCE_ERROR_INVALID_PARAMETER;
+ if(!keyname) {
+ ERR("keyname is null");
+ return PREFERENCE_ERROR_WRONG_PREFIX;
}
- /* insert data or update data if data already exist */
- ret = preference_is_existing(key, &exist);
- if (ret != PREFERENCE_ERROR_NONE)
- return ret;
-
- if (exist)
- snprintf(buf, sizeof(buf), "UPDATE %s SET %s=?1, %s=?2 WHERE %s=?3;",
- PREF_TBL_NAME, PREF_F_TYPE_NAME,
- PREF_F_DATA_NAME, PREF_F_KEY_NAME);
- else
- snprintf(buf, sizeof(buf),
- "INSERT INTO %s (%s, %s, %s) values (?3, ?1, ?2);",
- PREF_TBL_NAME, PREF_F_KEY_NAME,
- PREF_F_TYPE_NAME, PREF_F_DATA_NAME);
- ret = _prepare_and_bind_stmt(buf, type, data, key, &stmt);
+ char convert_key[PREFERENCE_KEY_PATH_LEN] = {0,};
+ char *chrptr = NULL;
+ char *pref_dir_path = NULL;
- if (ret != PREFERENCE_ERROR_NONE)
- return ret;
+ strncpy(convert_key, keyname, strlen(keyname));
- ret = sqlite3_step(stmt);
- if (ret != SQLITE_DONE) {
- LOGE("IO_ERROR(0x%08x): fail to write data(%d/%s)",
- PREFERENCE_ERROR_IO_ERROR,
- sqlite3_extended_errcode(pref_db),
- sqlite3_errmsg(pref_db));
- sqlite3_finalize(stmt);
+ pref_dir_path = _preference_get_pref_dir_path();
+ if (!pref_dir_path)
+ {
+ LOGE("_preference_get_pref_dir_path() failed.");
return PREFERENCE_ERROR_IO_ERROR;
}
- sqlite3_finalize(stmt);
+ chrptr = strchr((const char*)convert_key, (int)'/');
+ if(!chrptr) {
+ key = (const char*)convert_key;
+ }
+ else {
+ chrptr = strchr((const char*)convert_key, (int)'/');
+ while(chrptr) {
+ convert_key[chrptr-convert_key] = DELIMITER;
+ chrptr = strchr((const char*)chrptr+1, (int)'/');
+ }
+ key = (const char*)convert_key;
+ }
+
+ snprintf(path, PREFERENCE_KEY_PATH_LEN, "%s%s", pref_dir_path, key);
return PREFERENCE_ERROR_NONE;
}
-static int _read_data(const char *key, char *type, char *data)
+static int _preference_set_key_check_pref_dir()
{
- int ret;
- char *buf;
- char **result;
- int rows;
- int columns;
- char *errmsg;
+ char *pref_dir_path = NULL;
+ mode_t dir_mode = 0664 | 0111;
- if (key == NULL || key[0] == '\0' || data == NULL) {
- LOGE("INVALID_PARAMETER(0x%08x)",
- PREFERENCE_ERROR_INVALID_PARAMETER);
- return PREFERENCE_ERROR_INVALID_PARAMETER;
+ pref_dir_path = _preference_get_pref_dir_path();
+ if (!pref_dir_path)
+ {
+ LOGE("_preference_get_pref_dir_path() failed.");
+ return PREFERENCE_ERROR_IO_ERROR;
}
- if (pref_db == NULL) {
- if (_initialize() != PREFERENCE_ERROR_NONE) {
- LOGE("IO_ERROR(0x%08x) : fail to initialize db",
- PREFERENCE_ERROR_IO_ERROR);
+ if (access(pref_dir_path, F_OK) < 0)
+ {
+ if (mkdir(pref_dir_path, dir_mode) < 0)
+ {
+ ERR("mkdir() failed(%d/%s)", errno, strerror(errno));
return PREFERENCE_ERROR_IO_ERROR;
}
}
- buf = sqlite3_mprintf("SELECT %s, %s, %s FROM %s WHERE %s=%Q;",
- PREF_F_KEY_NAME, PREF_F_TYPE_NAME, PREF_F_DATA_NAME,
- PREF_TBL_NAME, PREF_F_KEY_NAME, key);
+ return PREFERENCE_ERROR_NONE;
+}
- if (buf == NULL) {
- LOGE("IO_ERROR(0x%08x) : fail to create query string",
- PREFERENCE_ERROR_IO_ERROR);
+static int _preference_set_key_creation(const char* path)
+{
+ int fd;
+ mode_t temp;
+ temp = umask(0000);
+ fd = open(path, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
+ umask(temp);
+ if(fd == -1) {
+ ERR("open(rdwr,create) error: %d(%s)", errno, strerror(errno));
return PREFERENCE_ERROR_IO_ERROR;
}
+ close(fd);
- ret = sqlite3_get_table(pref_db, buf, &result, &rows, &columns, &errmsg);
- sqlite3_free(buf);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to read data (%s)",
- PREFERENCE_ERROR_IO_ERROR, errmsg);
- sqlite3_free(errmsg);
- return PREFERENCE_ERROR_IO_ERROR;
- }
+ return PREFERENCE_ERROR_NONE;
+}
- if (rows == 0) {
- LOGE("NO_KEY(0x%08x) : fail to find given key(%s)",
- PREFERENCE_ERROR_NO_KEY, key);
- sqlite3_free_table(result);
- return PREFERENCE_ERROR_NO_KEY;
- }
+static int _preference_set_file_lock(int fd, short type)
+{
+ struct flock l;
- snprintf(type, 2, "%s", result[4]);
- snprintf(data, BUF_LEN, "%s", result[5]);
+ l.l_type = type;
+ l.l_start= 0; /*Start at begin*/
+ l.l_whence = SEEK_SET;
+ l.l_len = 0; /*Do it with whole file*/
- sqlite3_free_table(result);
+ return fcntl(fd, F_SETLK, &l);
+}
- return PREFERENCE_ERROR_NONE;
+static int _preference_get_pid_of_file_lock_owner(int fd, short type)
+{
+ struct flock l;
+
+ l.l_type = type;
+ l.l_start= 0; /*Start at begin*/
+ l.l_whence = SEEK_SET;
+ l.l_len = 0; /*Do it with whole file*/
+
+ if(fcntl(fd, F_GETLK, &l) < 0) {
+ WARN("error in getting lock info");
+ return -1;
+ }
+
+ if(l.l_type == F_UNLCK)
+ return 0;
+ else
+ return l.l_pid;
}
-int preference_set_int(const char *key, int value)
+static int _preference_set_read_lock(int fd)
{
- char type[2];
- char data[BUF_LEN];
- snprintf(type, 2, "%d", PREFERENCE_TYPE_INT);
- snprintf(data, BUF_LEN, "%d", value);
- return _write_data(key, type, data);
+ return _preference_set_file_lock(fd, F_RDLCK);
}
-int preference_get_int(const char *key, int *value)
+static int _preference_set_write_lock(int fd)
{
- char type[2];
- char data[BUF_LEN];
- int ret;
+ return _preference_set_file_lock(fd, F_WRLCK);
+}
- if (value == NULL) {
- LOGE("INVALID_PARAMETER(0x%08x)",
- PREFERENCE_ERROR_INVALID_PARAMETER);
- return PREFERENCE_ERROR_INVALID_PARAMETER;
- }
+static int _preference_set_unlock(int fd)
+{
+ return _preference_set_file_lock(fd, F_UNLCK);
+}
- ret = _read_data(key, type, data);
- if (ret == PREFERENCE_ERROR_NONE) {
- if (atoi(type) == PREFERENCE_TYPE_INT)
- *value = atoi(data);
- else {
- LOGE("INVALID_PARAMETER(0x%08x) : param type(%d)",
- PREFERENCE_ERROR_INVALID_PARAMETER, atoi(type));
- return PREFERENCE_ERROR_INVALID_PARAMETER;
+static int _preference_check_retry_err(keynode_t *keynode, int preference_errno, int io_errno, int op_type)
+{
+ int is_busy_err = 0;
+
+ if (preference_errno == PREFERENCE_ERROR_FILE_OPEN)
+ {
+ switch (io_errno)
+ {
+ case ENOENT :
+ {
+ if(op_type == PREFERENCE_OP_SET)
+ {
+ int rc = 0;
+ char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+ rc = _preference_get_key_path(keynode->keyname, path);
+ if (rc != PREFERENCE_ERROR_NONE) {
+ ERR("_preference_get_key_path error");
+ break;
+ }
+
+ rc = _preference_set_key_check_pref_dir();
+ if (rc != PREFERENCE_ERROR_NONE) {
+ ERR("_preference_set_key_check_pref_dir() failed.");
+ break;
+ }
+
+ preference_errno = _preference_set_key_creation(path);
+ if (rc != PREFERENCE_ERROR_NONE) {
+ ERR("_preference_set_key_creation error : %s", path);
+ break;
+ }
+ INFO("%s key is created", keynode->keyname);
+
+ is_busy_err = 1;
+ }
+ break;
+ }
+ case EAGAIN :
+ case EMFILE :
+ case ENFILE :
+ case ETXTBSY :
+ {
+ is_busy_err = 1;
+ }
+ }
+ }
+ else if (preference_errno == PREFERENCE_ERROR_FILE_CHMOD)
+ {
+ switch (io_errno)
+ {
+ case EINTR :
+ case EBADF :
+ {
+ is_busy_err = 1;
+ }
+ }
+ }
+ else if (preference_errno == PREFERENCE_ERROR_FILE_LOCK)
+ {
+ switch (io_errno)
+ {
+ case EBADF :
+ case EAGAIN :
+ case ENOLCK :
+ {
+ is_busy_err = 1;
+ }
}
}
+ else if (preference_errno == PREFERENCE_ERROR_FILE_WRITE)
+ {
+ switch (io_errno)
+ {
+ case 0 :
+ case EAGAIN :
+ case EINTR :
+ case EIO :
+ case ENOMEM :
+ {
+ is_busy_err = 1;
+ }
+ }
+ }
+ else if (preference_errno == PREFERENCE_ERROR_FILE_FREAD)
+ {
+ switch (io_errno)
+ {
+ case EAGAIN :
+ case EINTR :
+ case EIO :
+ {
+ is_busy_err = 1;
+ }
+ }
+ }
+ else
+ {
+ is_busy_err = 0;
+ }
- return ret;
+ if (is_busy_err == 1) {
+ return 1;
+ }
+ else
+ {
+ ERR("key(%s), check retry err: %d/(%d/%s).",keynode->keyname, preference_errno, io_errno, strerror(io_errno));
+ return 0;
+ }
}
-int preference_set_double(const char *key, double value)
+static int _preference_set_key_filesys(keynode_t *keynode, int *io_errno)
{
- char type[2];
- char data[BUF_LEN];
- snprintf(type, 2, "%d", PREFERENCE_TYPE_DOUBLE);
- snprintf(data, BUF_LEN, "%f", value);
- return _write_data(key, type, data);
-}
+ char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+ FILE *fp = NULL;
+ int ret = -1;
+ int func_ret = PREFERENCE_ERROR_NONE;
+ int err_no = 0;
+ char err_buf[100] = { 0, };
+ int is_write_error = 0;
+ int retry_cnt = 0;
+
+retry_open :
+ errno = 0;
+ err_no = 0;
+ func_ret = PREFERENCE_ERROR_NONE;
+
+ ret = _preference_get_key_path(keynode->keyname, path);
+ retv_if(ret != PREFERENCE_ERROR_NONE, ret);
+
+ if( (fp = fopen(path, "r+")) == NULL ) {
+ func_ret = PREFERENCE_ERROR_FILE_OPEN;
+ err_no = errno;
+ goto out_return;
+ }
-int preference_get_double(const char *key, double *value)
-{
- char type[2];
- char data[BUF_LEN];
+retry :
+ errno = 0;
+ err_no = 0;
+ func_ret = PREFERENCE_ERROR_NONE;
+
+ ret = _preference_set_write_lock(fileno(fp));
+ if(ret == -1) {
+ func_ret = PREFERENCE_ERROR_FILE_LOCK;
+ err_no = errno;
+ ERR("file(%s) lock owner(%d)",
+ keynode->keyname,
+ _preference_get_pid_of_file_lock_owner(fileno(fp), F_WRLCK));
+ goto out_return;
+ }
- int ret;
+ /* write key type */
+ ret = fwrite((void *)&(keynode->type), sizeof(int), 1, fp);
+ if(ret <= 0)
+ {
+ if(!errno) {
+ LOGW("number of written items is 0. try again");
+ errno = EAGAIN;
+ }
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_WRITE;
+ goto out_unlock;
+ }
- if (value == NULL) {
- LOGE("INVALID_PARAMETER(0x%08x)",
- PREFERENCE_ERROR_INVALID_PARAMETER);
- return PREFERENCE_ERROR_INVALID_PARAMETER;
+ /* write key value */
+ switch(keynode->type)
+ {
+ case PREFERENCE_TYPE_INT:
+ ret = fwrite((void *)&(keynode->value.i), sizeof(int), 1, fp);
+ if(ret <= 0) is_write_error = 1;
+ break;
+ case PREFERENCE_TYPE_DOUBLE:
+ ret = fwrite((void *)&(keynode->value.d), sizeof(double), 1, fp);
+ if(ret <= 0) is_write_error = 1;
+ break;
+ case PREFERENCE_TYPE_BOOLEAN:
+ ret = fwrite((void *)&(keynode->value.b), sizeof(int), 1, fp);
+ if(ret <= 0) is_write_error = 1;
+ break;
+ case PREFERENCE_TYPE_STRING:
+ ret = fprintf(fp,"%s",keynode->value.s);
+ if(ret < strlen(keynode->value.s)) is_write_error = 1;
+ if (ftruncate(fileno(fp), ret) == -1) {
+ is_write_error = 1;
+ }
+ break;
+ default :
+ func_ret = PREFERENCE_ERROR_WRONG_TYPE;
+ goto out_unlock;
+ }
+ if(is_write_error)
+ {
+ if(!errno) {
+ LOGW("number of written items is 0. try again");
+ errno = EAGAIN;
+ }
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_WRITE;
+ goto out_unlock;
}
- ret = _read_data(key, type, data);
- if (ret == PREFERENCE_ERROR_NONE) {
- if (atoi(type) == PREFERENCE_TYPE_DOUBLE)
- *value = atof(data);
- else {
- LOGE("INVALID_PARAMETER(0x%08x) : param type(%d)",
- PREFERENCE_ERROR_INVALID_PARAMETER, atoi(type));
- return PREFERENCE_ERROR_INVALID_PARAMETER;
+ fflush(fp);
+
+out_unlock :
+ ret = _preference_set_unlock(fileno(fp));
+ if(ret == -1) {
+ func_ret = PREFERENCE_ERROR_FILE_LOCK;
+ err_no = errno;
+ goto out_return;
+ }
+
+out_return :
+ if (func_ret != PREFERENCE_ERROR_NONE)
+ {
+ strerror_r(err_no, err_buf, 100);
+ if (_preference_check_retry_err(keynode, func_ret, err_no, PREFERENCE_OP_SET))
+ {
+ if (retry_cnt < PREFERENCE_ERROR_RETRY_CNT)
+ {
+ WARN("_preference_set_key_filesys(%d-%s) step(%d) failed(%d / %s) retry(%d)", keynode->type, keynode->keyname, func_ret, err_no, err_buf, retry_cnt);
+ retry_cnt++;
+ usleep((retry_cnt)*PREFERENCE_ERROR_RETRY_SLEEP_UTIME);
+
+ if (fp)
+ goto retry;
+ else
+ goto retry_open;
+ }
+ else
+ {
+ ERR("_preference_set_key_filesys(%d-%s) step(%d) faild(%d / %s) over the retry count.",
+ keynode->type, keynode->keyname, func_ret, err_no, err_buf);
+ }
+ }
+ else
+ {
+ ERR("_preference_set_key_filesys(%d-%s) step(%d) failed(%d / %s)\n", keynode->type, keynode->keyname, func_ret, err_no, err_buf);
+ }
+ } else {
+ if(retry_cnt > 0) {
+ DBG("_preference_set_key_filesys ok with retry cnt(%d)", retry_cnt);
}
}
+ if (fp)
+ {
+ if(func_ret == PREFERENCE_ERROR_NONE)
+ {
+ ret = fdatasync(fileno(fp));
+ if(ret == -1) {
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_SYNC;
+ }
+ }
+ fclose(fp);
+ }
+ *io_errno = err_no;
+
+ return func_ret;
+}
+
+static int _preference_set_key(keynode_t *keynode)
+{
+ int ret = 0;
+ int io_errno = 0;
+ char err_buf[100] = { 0, };
+
+ ret = _preference_set_key_filesys(keynode, &io_errno);
+ if (ret == PREFERENCE_ERROR_NONE)
+ {
+ g_posix_errno = PREFERENCE_ERROR_NONE;
+ g_preference_errno = PREFERENCE_ERROR_NONE;
+ }
+ else
+ {
+ strerror_r(io_errno, err_buf, 100);
+ ERR("_preference_set_key(%s) step(%d) failed(%d / %s)", keynode->keyname, ret, io_errno, err_buf);
+ g_posix_errno = io_errno;
+ g_preference_errno = ret;
+ }
+
return ret;
}
-int preference_set_string(const char *key, const char *value)
+
+/*
+ * This function set the integer value of given key
+ * @param[in] key key
+ * @param[in] intval integer value to set
+ * @return 0 on success, -1 on error
+ */
+API int preference_set_int(const char *key, int intval)
{
- char type[2];
+ START_TIME_CHECK
+
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is NULL");
+
+ int func_ret = PREFERENCE_ERROR_NONE;
- snprintf(type, 2, "%d", PREFERENCE_TYPE_STRING);
- if (strlen(value) > (BUF_LEN-1)) {
- LOGE("INVALID_PARAMETER(0x%08x) : param type(%d)",
- PREFERENCE_ERROR_INVALID_PARAMETER, atoi(type));
- return PREFERENCE_ERROR_INVALID_PARAMETER;
+ keynode_t* pKeyNode = _preference_keynode_new();
+ retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
+
+ func_ret = _preference_keynode_set_keyname(pKeyNode, key);
+ if(func_ret != PREFERENCE_ERROR_NONE) {
+ _preference_keynode_free(pKeyNode);
+ ERR("set key name error");
+ return PREFERENCE_ERROR_IO_ERROR;
}
- return _write_data(key, type, value);
+ _preference_keynode_set_value_int(pKeyNode, intval);
+
+ if (_preference_set_key(pKeyNode) != PREFERENCE_ERROR_NONE) {
+ ERR("preference_set_int(%d) : key(%s/%d) error", getpid(), key, intval);
+ func_ret = PREFERENCE_ERROR_IO_ERROR;
+ } else{
+ INFO("%s(%d) success", key, intval);
+ }
+
+ _preference_keynode_free(pKeyNode);
+
+ END_TIME_CHECK
+
+ return func_ret;
}
-int preference_get_string(const char *key, char **value)
+/*
+* This function set the boolean value of given key
+* @param[in] key key
+* @param[in] boolval boolean value to set
+ (Integer value 1 is 'True', and 0 is 'False')
+* @return 0 on success, -1 on error
+*/
+API int preference_set_boolean(const char *key, bool boolval)
{
- char type[2];
- char data[BUF_LEN];
+ START_TIME_CHECK
- int ret;
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is NULL");
- if (value == NULL) {
- LOGE("INVALID_PARAMETER(0x%08x)",
- PREFERENCE_ERROR_INVALID_PARAMETER);
- return PREFERENCE_ERROR_INVALID_PARAMETER;
+ int func_ret = PREFERENCE_ERROR_NONE;
+ keynode_t* pKeyNode = _preference_keynode_new();
+ retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
+
+ func_ret = _preference_keynode_set_keyname(pKeyNode, key);
+ if(func_ret != PREFERENCE_ERROR_NONE) {
+ _preference_keynode_free(pKeyNode);
+ ERR("set key name error");
+ return PREFERENCE_ERROR_IO_ERROR;
}
+ _preference_keynode_set_value_boolean(pKeyNode, boolval);
- ret = _read_data(key, type, data);
- if (ret == PREFERENCE_ERROR_NONE) {
- if (atoi(type) == PREFERENCE_TYPE_STRING) {
- *value = strdup(data);
- if (value == NULL) {
- LOGE("OUT_OF_MEMORY(0x%08x)",
- PREFERENCE_ERROR_OUT_OF_MEMORY);
- return PREFERENCE_ERROR_OUT_OF_MEMORY;
- }
- } else {
- LOGE("INVALID_PARAMETER(0x%08x) : param type(%d)",
- PREFERENCE_ERROR_INVALID_PARAMETER, atoi(type));
- return PREFERENCE_ERROR_INVALID_PARAMETER;
- }
+ if (_preference_set_key(pKeyNode) != PREFERENCE_ERROR_NONE) {
+ ERR("preference_set_boolean(%d) : key(%s/%d) error", getpid(), key, boolval);
+ func_ret = PREFERENCE_ERROR_IO_ERROR;
+ } else {
+ INFO("%s(%d) success", key, boolval);
}
- return ret;
+ _preference_keynode_free(pKeyNode);
+
+ END_TIME_CHECK
+
+ return func_ret;
}
-int preference_set_boolean(const char *key, bool value)
+/*
+ * This function set the double value of given key
+ * @param[in] key key
+ * @param[in] dblval double value to set
+ * @return 0 on success, -1 on error
+ */
+API int preference_set_double(const char *key, double dblval)
{
- char type[2];
- char data[BUF_LEN];
- snprintf(type, 2, "%d", PREFERENCE_TYPE_BOOLEAN);
- snprintf(data, BUF_LEN, "%d", value);
- return _write_data(key, type, data);
+ START_TIME_CHECK
+
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is NULL");
+
+ int func_ret = PREFERENCE_ERROR_NONE;
+ keynode_t* pKeyNode = _preference_keynode_new();
+ retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
+
+ func_ret = _preference_keynode_set_keyname(pKeyNode, key);
+ if(func_ret != PREFERENCE_ERROR_NONE) {
+ _preference_keynode_free(pKeyNode);
+ ERR("set key name error");
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ _preference_keynode_set_value_double(pKeyNode, dblval);
+
+ if (_preference_set_key(pKeyNode) != PREFERENCE_ERROR_NONE) {
+ ERR("preference_set_double(%d) : key(%s/%f) error", getpid(), key, dblval);
+ func_ret = PREFERENCE_ERROR_IO_ERROR;
+ } else {
+ INFO("%s(%f) success", key, dblval);
+ }
+
+ _preference_keynode_free(pKeyNode);
+
+ END_TIME_CHECK
+
+ return func_ret;
}
-int preference_get_boolean(const char *key, bool *value)
+/*
+ * This function set the string value of given key
+ * @param[in] key key
+ * @param[in] strval string value to set
+ * @return 0 on success, -1 on error
+ */
+API int preference_set_string(const char *key, const char *strval)
{
- char type[2];
- char data[BUF_LEN];
+ START_TIME_CHECK
- int ret;
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is NULL");
+ retvm_if(strval == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: value is NULL");
- if (value == NULL) {
- LOGE("INVALID_PARAMETER(0x%08x)",
- PREFERENCE_ERROR_INVALID_PARAMETER);
- return PREFERENCE_ERROR_INVALID_PARAMETER;
+ int func_ret = PREFERENCE_ERROR_NONE;
+ keynode_t* pKeyNode = _preference_keynode_new();
+ retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
+
+ func_ret = _preference_keynode_set_keyname(pKeyNode, key);
+ if(func_ret != PREFERENCE_ERROR_NONE) {
+ _preference_keynode_free(pKeyNode);
+ ERR("set key name error");
+ return PREFERENCE_ERROR_IO_ERROR;
}
+ _preference_keynode_set_value_string(pKeyNode, strval);
- ret = _read_data(key, type, data);
- if (ret == PREFERENCE_ERROR_NONE) {
- if (atoi(type) == PREFERENCE_TYPE_BOOLEAN)
- *value = (bool)atoi(data);
- else {
- LOGE("INVALID_PARAMETER(0x%08x) : param type(%d)",
- PREFERENCE_ERROR_INVALID_PARAMETER, atoi(type));
- return PREFERENCE_ERROR_INVALID_PARAMETER;
- }
+ if (_preference_set_key(pKeyNode) != PREFERENCE_ERROR_NONE) {
+ ERR("preference_set_string(%d) : key(%s/%s) error", getpid(), key, strval);
+ func_ret = PREFERENCE_ERROR_IO_ERROR;
+ } else {
+ INFO("%s(%s) success", key, strval);
}
- return ret;
-}
+ _preference_keynode_free(pKeyNode);
+ END_TIME_CHECK
-/* TODO: below operation is too heavy, let's find the light way to check. */
-int preference_is_existing(const char *key, bool *exist)
+ return func_ret;
+}
+
+static int _preference_get_key_filesys(keynode_t *keynode, int* io_errno)
{
- int ret;
- char *buf;
- char **result;
- int rows;
- int columns;
- char *errmsg;
+ char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+ int ret = -1;
+ int func_ret = PREFERENCE_ERROR_NONE;
+ char err_buf[100] = { 0, };
+ int err_no = 0;
+ int type = 0;
+ FILE *fp = NULL;
+ int retry_cnt = 0;
+ int read_size = 0;
+
+retry_open :
+ errno = 0;
+ func_ret = PREFERENCE_ERROR_NONE;
+
+ ret = _preference_get_key_path(keynode->keyname, path);
+ retv_if(ret != PREFERENCE_ERROR_NONE, ret);
+
+ if( (fp = fopen(path, "r")) == NULL ) {
+ func_ret = PREFERENCE_ERROR_FILE_OPEN;
+ err_no = errno;
+ goto out_return;
+ }
- if (key == NULL || key[0] == '\0' || exist == NULL) {
- LOGE("INVALID_PARAMETER(0x%08x)",
- PREFERENCE_ERROR_INVALID_PARAMETER);
- return PREFERENCE_ERROR_INVALID_PARAMETER;
+retry :
+ err_no = 0;
+ func_ret = PREFERENCE_ERROR_NONE;
+
+ ret = _preference_set_read_lock(fileno(fp));
+ if(ret == -1) {
+ func_ret = PREFERENCE_ERROR_FILE_LOCK;
+ err_no = errno;
+ goto out_return;
}
- if (pref_db == NULL) {
- if (_initialize() != PREFERENCE_ERROR_NONE) {
- LOGE("IO_ERROR(0x%08x) : fail to initialize db",
- PREFERENCE_ERROR_IO_ERROR);
- return PREFERENCE_ERROR_IO_ERROR;
+
+ /* read data type */
+ read_size = fread((void*)&type, sizeof(int), 1, fp);
+ if((read_size <= 0) || (read_size > sizeof(int))) {
+ if(!ferror(fp)) {
+ LOGW("number of read items for type is 0 with false ferror. err : %d", errno);
+ errno = ENODATA;
}
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_FREAD;
+ goto out_unlock;
}
- /* check data is exist */
- buf = sqlite3_mprintf("SELECT %s FROM %s WHERE %s=%Q;",
- PREF_F_KEY_NAME, PREF_TBL_NAME, PREF_F_KEY_NAME, key);
+ /* read data value */
+ switch(type)
+ {
+ case PREFERENCE_TYPE_INT:
+ {
+ int value_int = 0;
+ int read_size = 0;
+ read_size = fread((void*)&value_int, sizeof(int), 1, fp);
+ if((read_size <= 0) || (read_size > sizeof(int))) {
+ if(!ferror(fp)) {
+ LOGW("number of read items for value is wrong. err : %d", errno);
+ }
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_FREAD;
+ goto out_unlock;
+ } else {
+ _preference_keynode_set_value_int(keynode, value_int);
+ }
- if (buf == NULL) {
- LOGE("IO_ERROR(0x%08x) : fail to create query string",
- PREFERENCE_ERROR_IO_ERROR);
- return PREFERENCE_ERROR_IO_ERROR;
+ break;
+ }
+ case PREFERENCE_TYPE_DOUBLE:
+ {
+ double value_dbl = 0;
+ int read_size = 0;
+ read_size = fread((void*)&value_dbl, sizeof(double), 1, fp);
+ if((read_size <= 0) || (read_size > sizeof(double))) {
+ if(!ferror(fp)) {
+ LOGW("number of read items for value is wrong. err : %d", errno);
+ }
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_FREAD;
+ goto out_unlock;
+ } else {
+ _preference_keynode_set_value_double(keynode, value_dbl);
+ }
+
+ break;
+ }
+ case PREFERENCE_TYPE_BOOLEAN:
+ {
+ int value_int = 0;
+ int read_size = 0;
+ read_size = fread((void*)&value_int, sizeof(int), 1, fp);
+ if((read_size <= 0) || (read_size > sizeof(int))) {
+ if(!ferror(fp)) {
+ LOGW("number of read items for value is wrong. err : %d", errno);
+ }
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_FREAD;
+ goto out_unlock;
+ } else {
+ _preference_keynode_set_value_boolean(keynode, value_int);
+ }
+
+ break;
+ }
+ case PREFERENCE_TYPE_STRING:
+ {
+ char file_buf[BUF_LEN] = {0,};
+ char *value = NULL;
+ int value_size = 0;
+
+ while(fgets(file_buf, sizeof(file_buf), fp))
+ {
+ if(value) {
+ value_size = value_size + strlen(file_buf);
+ value = (char *) realloc(value, value_size);
+ if(value == NULL) {
+ func_ret = PREFERENCE_ERROR_OUT_OF_MEMORY;
+ break;
+ }
+ strncat(value, file_buf, strlen(file_buf));
+ } else {
+ value_size = strlen(file_buf) + 1;
+ value = (char *)malloc(value_size);
+ if(value == NULL) {
+ func_ret = PREFERENCE_ERROR_OUT_OF_MEMORY;
+ break;
+ }
+ memset(value, 0x00, value_size);
+ strncpy(value, file_buf, strlen(file_buf));
+ }
+ }
+
+ if(ferror(fp)) {
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_FGETS;
+ } else {
+ if(value) {
+ _preference_keynode_set_value_string(keynode, value);
+ } else {
+ _preference_keynode_set_value_string(keynode, "");
+ }
+ }
+ if(value)
+ free(value);
+
+ break;
+ }
+ default :
+ func_ret = PREFERENCE_ERROR_WRONG_TYPE;
}
- ret = sqlite3_get_table(pref_db, buf, &result, &rows, &columns, &errmsg);
- sqlite3_free(buf);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to read data(%s)",
- PREFERENCE_ERROR_IO_ERROR, errmsg);
- sqlite3_free(errmsg);
- return PREFERENCE_ERROR_IO_ERROR;
+out_unlock :
+ ret = _preference_set_unlock(fileno(fp));
+ if(ret == -1) {
+ func_ret = PREFERENCE_ERROR_FILE_LOCK;
+ err_no = errno;
+ goto out_return;
}
- if (rows > 0)
- *exist = true;
- else
- *exist = false;
- sqlite3_free_table(result);
- return PREFERENCE_ERROR_NONE;
-}
+out_return :
+ if (func_ret != PREFERENCE_ERROR_NONE)
+ {
+ strerror_r(err_no, err_buf, 100);
+
+ if (_preference_check_retry_err(keynode, func_ret, err_no, PREFERENCE_OP_GET))
+ {
+ if (retry_cnt < PREFERENCE_ERROR_RETRY_CNT)
+ {
+ WARN("_preference_get_key_filesys(%s) step(%d) failed(%d / %s) retry(%d)",
+ keynode->keyname, func_ret, err_no, err_buf, retry_cnt);
+ retry_cnt++;
+ usleep((retry_cnt)*PREFERENCE_ERROR_RETRY_SLEEP_UTIME);
+
+ if (fp)
+ goto retry;
+ else
+ goto retry_open;
+ }
+ else
+ {
+ ERR("_preference_get_key_filesys(%s) step(%d) faild(%d / %s) over the retry count.",
+ keynode->keyname, func_ret, err_no, err_buf);
+ }
+ }
+ else
+ {
+ ERR("_preference_get_key_filesys(%s) step(%d) failed(%d / %s) retry(%d) ",
+ keynode->keyname, func_ret, err_no, err_buf, retry_cnt);
+ }
+ } else {
+ if(retry_cnt > 0) {
+ DBG("preference get filesys ok with retry cnt(%d)", retry_cnt);
+ }
+ }
-static pref_changed_cb_node_t *_find_node(const char *key)
-{
- pref_changed_cb_node_t *tmp_node;
+ if (fp)
+ fclose(fp);
- if (key == NULL || key[0] == '\0')
- return NULL;
+ *io_errno = err_no;
- tmp_node = head;
+ return func_ret;
+}
- while (tmp_node) {
- if (strcmp(tmp_node->key, key) == 0)
- break;
- tmp_node = tmp_node->next;
+int _preference_get_key(keynode_t *keynode)
+{
+ int ret = 0;
+ int io_errno = 0;
+ char err_buf[100] = {0,};
+
+ ret = _preference_get_key_filesys(keynode, &io_errno);
+ if(ret == PREFERENCE_ERROR_NONE) {
+ g_posix_errno = PREFERENCE_ERROR_NONE;
+ g_preference_errno = PREFERENCE_ERROR_NONE;
+ }
+ else
+ {
+ if (io_errno == ENOENT)
+ ret = PREFERENCE_ERROR_NO_KEY;
+ else
+ ret = PREFERENCE_ERROR_IO_ERROR;
+
+ strerror_r(io_errno, err_buf, 100);
+ ERR("_preference_get_key(%s) step(%d) failed(%d / %s)\n", keynode->keyname, ret, io_errno, err_buf);
+ g_posix_errno = io_errno;
+ g_preference_errno = ret;
}
- return tmp_node;
+ return ret;
}
-static int _add_node(const char *key, preference_changed_cb cb, void *user_data)
+/*
+ * This function get the integer value of given key
+ * @param[in] key key
+ * @param[out] intval output buffer
+ * @return 0 on success, -1 on error
+ */
+API int preference_get_int(const char *key, int *intval)
{
- pref_changed_cb_node_t *tmp_node;
+ START_TIME_CHECK
- if (key == NULL || key[0] == '\0' || cb == NULL) {
- LOGE("INVALID_PARAMETER(0x%08x)",
- PREFERENCE_ERROR_INVALID_PARAMETER);
- return PREFERENCE_ERROR_INVALID_PARAMETER;
- }
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
+ retvm_if(intval == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: output buffer is null");
+
+ int func_ret = PREFERENCE_ERROR_IO_ERROR;
+ keynode_t* pKeyNode = _preference_keynode_new();
+ retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
- tmp_node = _find_node(key);
+ _preference_keynode_set_keyname(pKeyNode, key);
- if (tmp_node != NULL) {
- tmp_node->cb = cb;
- tmp_node->user_data = user_data;
+ func_ret = _preference_get_key(pKeyNode);
+
+ if (func_ret != PREFERENCE_ERROR_NONE) {
+ ERR("preference_get_int(%d) : key(%s) error", getpid(), key);
} else {
- tmp_node =
- (pref_changed_cb_node_t *)malloc(sizeof(pref_changed_cb_node_t));
- if (tmp_node == NULL) {
- LOGE("OUT_OF_MEMORY(0x%08x)",
- PREFERENCE_ERROR_OUT_OF_MEMORY);
- return PREFERENCE_ERROR_OUT_OF_MEMORY;
+ *intval = pKeyNode->value.i;
+ if(pKeyNode->type == PREFERENCE_TYPE_INT) {
+ INFO("%s(%d) success", key, *intval);
+ func_ret = PREFERENCE_ERROR_NONE;
+ } else {
+ ERR("The type(%d) of keynode(%s) is not INT", pKeyNode->type, pKeyNode->keyname);
+ func_ret = PREFERENCE_ERROR_INVALID_PARAMETER;
}
+ }
- tmp_node->key = strdup(key);
- if (tmp_node->key == NULL) {
- free(tmp_node);
- LOGE("OUT_OF_MEMORY(0x%08x)", PREFERENCE_ERROR_OUT_OF_MEMORY);
- return PREFERENCE_ERROR_OUT_OF_MEMORY;
- }
+ _preference_keynode_free(pKeyNode);
- if (head != NULL)
- head->prev = tmp_node;
- tmp_node->cb = cb;
- tmp_node->user_data = user_data;
- tmp_node->prev = NULL;
- tmp_node->next = head;
- head = tmp_node;
- }
+ END_TIME_CHECK
- return PREFERENCE_ERROR_NONE;
+ return func_ret;
}
-static int _remove_node(const char *key)
+/*
+ * This function get the boolean value of given key
+ * @param[in] key key
+ * @param[out] boolval output buffer
+ * @return 0 on success, -1 on error
+ */
+API int preference_get_boolean(const char *key, bool *boolval)
{
- pref_changed_cb_node_t *tmp_node;
+ START_TIME_CHECK
- if (key == NULL || key[0] == '\0') {
- LOGE("INVALID_PARAMETER(0x%08x)",
- PREFERENCE_ERROR_INVALID_PARAMETER);
- return PREFERENCE_ERROR_INVALID_PARAMETER;
- }
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
+ retvm_if(boolval == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: output buffer is null");
- tmp_node = _find_node(key);
+ int func_ret = PREFERENCE_ERROR_IO_ERROR;
+ keynode_t* pKeyNode = _preference_keynode_new();
+ retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
- if (tmp_node == NULL)
- return PREFERENCE_ERROR_NONE;
+ _preference_keynode_set_keyname(pKeyNode, key);
- if (tmp_node->prev != NULL)
- tmp_node->prev->next = tmp_node->next;
- else
- head = tmp_node->next;
+ func_ret = _preference_get_key(pKeyNode);
- if (tmp_node->next != NULL)
- tmp_node->next->prev = tmp_node->prev;
+ if (func_ret != PREFERENCE_ERROR_NONE) {
+ ERR("preference_get_boolean(%d) : %s error", getpid(), key);
+ } else {
+ *boolval = !!(pKeyNode->value.b);
+ if(pKeyNode->type == PREFERENCE_TYPE_BOOLEAN) {
+ INFO("%s(%d) success", key, *boolval);
+ func_ret = PREFERENCE_ERROR_NONE;
+ } else {
+ ERR("The type(%d) of keynode(%s) is not BOOL", pKeyNode->type, pKeyNode->keyname);
+ func_ret = PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+ }
- if (tmp_node->key)
- free(tmp_node->key);
+ _preference_keynode_free(pKeyNode);
- free(tmp_node);
+ END_TIME_CHECK
- return PREFERENCE_ERROR_NONE;
+ return func_ret;
}
-
-static void _remove_all_node(void)
+/*
+ * This function get the double value of given key
+ * @param[in] key key
+ * @param[out] dblval output buffer
+ * @return 0 on success, -1 on error
+ */
+API int preference_get_double(const char *key, double *dblval)
{
- pref_changed_cb_node_t *tmp_node;
+ START_TIME_CHECK
- while (head) {
- tmp_node = head;
- head = tmp_node->next;
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
+ retvm_if(dblval == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: output buffer is null");
- if (tmp_node->key)
- free(tmp_node->key);
+ int func_ret = PREFERENCE_ERROR_IO_ERROR;
+ keynode_t* pKeyNode = _preference_keynode_new();
+ retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
- free(tmp_node);
+ _preference_keynode_set_keyname(pKeyNode, key);
+
+ func_ret = _preference_get_key(pKeyNode);
+
+ if (func_ret != PREFERENCE_ERROR_NONE) {
+ ERR("preference_get_double(%d) : %s error", getpid(), key);
+ } else {
+ *dblval = pKeyNode->value.d;
+
+ if(pKeyNode->type == PREFERENCE_TYPE_DOUBLE) {
+ INFO("%s(%f) success", key, *dblval);
+ func_ret = PREFERENCE_ERROR_NONE;
+ } else {
+ ERR("The type(%d) of keynode(%s) is not DBL", pKeyNode->type, pKeyNode->keyname);
+ func_ret = PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
}
-}
+ _preference_keynode_free(pKeyNode);
+
+ END_TIME_CHECK
-static void _update_cb(void *data, int action, char const *db_name,
- char const *table_name, sqlite_int64 rowid)
+ return func_ret;
+}
+
+/*
+ * This function get the string value of given key
+ * @param[in] key key
+ * @return pointer of key value on success, NULL on error
+ */
+API int preference_get_string(const char *key, char **value)
{
- int ret;
- char *buf;
- char **result;
- int rows;
- int columns;
- char *errmsg;
- pref_changed_cb_node_t *tmp_node;
+ START_TIME_CHECK
- if (action != SQLITE_UPDATE)
- return;
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
+ retvm_if(value == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: output buffer is null");
- if (strcmp(table_name, PREF_TBL_NAME) != 0) {
- SECURE_LOGE("given table name (%s) is not same", table_name);
- return;
- }
+ int func_ret = PREFERENCE_ERROR_IO_ERROR;
+ keynode_t* pKeyNode = _preference_keynode_new();
+ retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
- buf = sqlite3_mprintf("SELECT %s FROM %s WHERE rowid='%lld';",
- PREF_F_KEY_NAME, PREF_TBL_NAME, rowid);
- if (buf == NULL)
- return;
+ _preference_keynode_set_keyname(pKeyNode, key);
- ret = sqlite3_get_table(pref_db, buf, &result, &rows, &columns, &errmsg);
- sqlite3_free(buf);
- if (ret != SQLITE_OK) {
- LOGI("fail to read data(%s)", errmsg);
- sqlite3_free(errmsg);
- return;
- }
+ char *tempstr = NULL;
+
+ func_ret = _preference_get_key(pKeyNode);
+
+ if (func_ret != PREFERENCE_ERROR_NONE) {
+ ERR("preference_get_string(%d) : %s error", getpid(), key);
+ } else {
+ if(pKeyNode->type == PREFERENCE_TYPE_STRING)
+ tempstr = pKeyNode->value.s;
+ else {
+ ERR("The type(%d) of keynode(%s) is not STR", pKeyNode->type, pKeyNode->keyname);
+ func_ret = PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
- if (rows == 0) {
- sqlite3_free_table(result);
- return;
+ if(tempstr) {
+ *value = strdup(tempstr);
+ INFO("%s(%s) success", key, value);
+ }
}
- tmp_node = _find_node(result[1]);
+ _preference_keynode_free(pKeyNode);
- if (tmp_node != NULL && tmp_node->cb != NULL)
- tmp_node->cb(result[1], tmp_node->user_data);
+ END_TIME_CHECK
- sqlite3_free_table(result);
+ return func_ret;
}
-
-int preference_remove(const char *key)
+/*
+ * This function unset given key
+ * @param[in] key key
+ * @return 0 on success, -1 on error
+ */
+API int preference_remove(const char *key)
{
- int ret;
- char buf[BUF_LEN];
- bool exist;
- sqlite3_stmt *stmt;
+ START_TIME_CHECK
- ret = preference_is_existing(key, &exist);
- if (ret != PREFERENCE_ERROR_NONE)
- return ret;
+ char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+ int ret = -1;
+ int err_retry = PREFERENCE_ERROR_RETRY_CNT;
+ int func_ret = PREFERENCE_ERROR_NONE;
- if (!exist)
- return PREFERENCE_ERROR_NO_KEY;
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
+
+ ret = _preference_get_key_path(key, path);
+ retvm_if(ret != PREFERENCE_ERROR_NONE, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is not valid");
- snprintf(buf, sizeof(buf), "DELETE FROM %s WHERE %s = ?",
- PREF_TBL_NAME, PREF_F_KEY_NAME);
+ retvm_if(access(path, F_OK) == -1, PREFERENCE_ERROR_NO_KEY, "Error : key(%s) is not exist", key);
- ret = sqlite3_prepare(pref_db, buf, -1, &stmt, NULL);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to prepare query (%d/%s)",
- PREFERENCE_ERROR_IO_ERROR,
- sqlite3_extended_errcode(pref_db),
- sqlite3_errmsg(pref_db));
+ do {
+ ret = remove(path);
+ if(ret == -1) {
+ ERR("preference_remove() failed. ret=%d(%s), key(%s)", errno, strerror(errno), key);
+ func_ret = PREFERENCE_ERROR_IO_ERROR;
+ } else {
+ func_ret = PREFERENCE_ERROR_NONE;
+ break;
+ }
+ } while(err_retry--);
+
+ END_TIME_CHECK
+
+ return func_ret;
+}
+
+API int preference_remove_all(void)
+{
+ START_TIME_CHECK
+
+ int ret = -1;
+ int err_retry = PREFERENCE_ERROR_RETRY_CNT;
+ int func_ret = PREFERENCE_ERROR_NONE;
+ DIR *dir;
+ struct dirent *dent = NULL;
+ char *pref_dir_path = NULL;
+
+ pref_dir_path = _preference_get_pref_dir_path();
+ if (!pref_dir_path)
+ {
+ LOGE("_preference_get_pref_dir_path() failed.");
return PREFERENCE_ERROR_IO_ERROR;
}
- ret = sqlite3_bind_text(stmt, 1, key, -1, SQLITE_STATIC);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to bind(1) query (%d/%s)",
- PREFERENCE_ERROR_IO_ERROR,
- sqlite3_extended_errcode(pref_db),
- sqlite3_errmsg(pref_db));
- sqlite3_finalize(stmt);
+ dir = opendir(pref_dir_path);
+ if (dir == NULL)
+ {
+ LOGE("opendir() failed. pref_path: %s, error: %d(%s)", pref_dir_path, errno, strerror(errno));
return PREFERENCE_ERROR_IO_ERROR;
}
- ret = sqlite3_step(stmt);
- if (ret != SQLITE_DONE) {
- LOGE("IO_ERROR(0x%08x): fail to delete data(%d/%s)",
- PREFERENCE_ERROR_IO_ERROR,
- sqlite3_extended_errcode(pref_db),
- sqlite3_errmsg(pref_db));
- sqlite3_finalize(stmt);
- return PREFERENCE_ERROR_IO_ERROR;
+ while ((dent = readdir(dir)))
+ {
+ const char *entry = dent->d_name;
+ char keyname[PREFERENCE_KEY_PATH_LEN] = {0,};
+ char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+
+ if (entry[0] == '.')
+ {
+ continue;
+ }
+
+ ret = _preference_get_key_name(entry, keyname);
+ if (ret != PREFERENCE_ERROR_NONE)
+ {
+ ERR("_preference_get_key_name() failed(%d)", ret);
+ closedir(dir);
+ return ret;
+ }
+
+ ret = preference_unset_changed_cb(keyname);
+ if (ret != PREFERENCE_ERROR_NONE)
+ {
+ ERR("preference_unset_changed_cb() failed(%d)", ret);
+ closedir(dir);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = _preference_get_key_path(keyname, path);
+ if (ret != PREFERENCE_ERROR_NONE)
+ {
+ ERR("_preference_get_key_path() failed(%d)", ret);
+ closedir(dir);
+ return ret;
+ }
+
+ // delete
+ do {
+ ret = remove(path);
+ if(ret == -1) {
+ ERR("preference_remove_all error: %d(%s)", errno, strerror(errno));
+ func_ret = PREFERENCE_ERROR_IO_ERROR;
+ } else {
+ func_ret = PREFERENCE_ERROR_NONE;
+ break;
+ }
+ } while(err_retry--);
}
- sqlite3_finalize(stmt);
+ closedir(dir);
- _remove_node(key);
+ END_TIME_CHECK
- return PREFERENCE_ERROR_NONE;
+ return func_ret;
}
-
-int preference_remove_all(void)
+int preference_is_existing(const char *key, bool *exist)
{
- int ret;
- char *buf;
- char *errmsg;
+ START_TIME_CHECK
- if (pref_db == NULL) {
- if (_initialize() != PREFERENCE_ERROR_NONE) {
- LOGE("IO_ERROR(0x%08x) : fail to initialize db",
- PREFERENCE_ERROR_IO_ERROR);
- return PREFERENCE_ERROR_IO_ERROR;
- }
- }
+ char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+ int ret = -1;
+ int func_ret = PREFERENCE_ERROR_NONE;
- /* insert data or update data if data already exist */
- buf = sqlite3_mprintf("DELETE FROM %s;", PREF_TBL_NAME);
- if (buf == NULL) {
- LOGE("IO_ERROR(0x%08x) : fail to create query string",
- PREFERENCE_ERROR_IO_ERROR);
- return PREFERENCE_ERROR_IO_ERROR;
- }
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
+ retvm_if(exist == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
- ret = sqlite3_exec(pref_db, buf, NULL, NULL, &errmsg);
- sqlite3_free(buf);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to delete data (%s)",
- PREFERENCE_ERROR_IO_ERROR, errmsg);
- sqlite3_free(errmsg);
- return PREFERENCE_ERROR_IO_ERROR;
+ ret = _preference_get_key_path(key, path);
+ retv_if(ret != PREFERENCE_ERROR_NONE, ret);
+
+ ret = access(path, F_OK);
+ if (ret == -1)
+ {
+ ERR("Error : key(%s) is not exist", key);
+ *exist = 0;
+ }
+ else
+ {
+ *exist = 1;
}
- _remove_all_node();
+ END_TIME_CHECK
- return PREFERENCE_ERROR_NONE;
+ return func_ret;
}
-int preference_set_changed_cb(const char *key,
- preference_changed_cb callback, void *user_data)
+API int preference_set_changed_cb(const char *key, preference_changed_cb callback, void *user_data)
{
- int ret;
+ START_TIME_CHECK
+
+ int ret = -1;
bool exist;
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
+ retvm_if(callback == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: cb(%p)", callback);
+
ret = preference_is_existing(key, &exist);
if (ret != PREFERENCE_ERROR_NONE)
+ {
return ret;
+ }
- if (!exist) {
- LOGE("NO_KEY(0x%08x) : fail to find given key(%s)",
- PREFERENCE_ERROR_NO_KEY, key);
+ if (!exist)
+ {
+ LOGE("NO_KEY(0x%08x) : fail to find given key(%s)", PREFERENCE_ERROR_NO_KEY, key);
return PREFERENCE_ERROR_NO_KEY;
}
- if (!is_update_hook_registered) {
- sqlite3_update_hook(pref_db, _update_cb, NULL);
- is_update_hook_registered = true;
+ if (_preference_kdb_add_notify(key, callback, user_data)) {
+ if(errno != 0 && errno != ENOENT) {
+ ERR("preference_notify_key_changed : key(%s) add notify fail", key);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
}
+ INFO("%s noti is added", key);
+
+ END_TIME_CHECK
- return _add_node(key, callback, user_data);
+ return PREFERENCE_ERROR_NONE;
}
-int preference_unset_changed_cb(const char *key)
+API int preference_unset_changed_cb(const char *key)
{
- int ret;
+ START_TIME_CHECK
+
+ int ret = -1;
bool exist;
+ retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
+
ret = preference_is_existing(key, &exist);
if (ret != PREFERENCE_ERROR_NONE)
+ {
return ret;
+ }
- if (!exist) {
- LOGE("NO_KEY(0x%08x) : fail to find given key(%s)",
- PREFERENCE_ERROR_NO_KEY, key);
+ if (!exist)
+ {
+ LOGE("NO_KEY(0x%08x) : fail to find given key(%s)", PREFERENCE_ERROR_NO_KEY, key);
return PREFERENCE_ERROR_NO_KEY;
}
- return _remove_node(key);
+ if (_preference_kdb_del_notify(key)) {
+ if (errno != 0 && errno != ENOENT) {
+ ERR("preference_unset_changed_cb() failed: key(%s) error(%d/%s)", key, errno, strerror(errno));
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ }
+ INFO("%s noti removed", key);
+
+ END_TIME_CHECK
+
+ return PREFERENCE_ERROR_NONE;
}
-int preference_foreach_item(preference_item_cb callback, void *user_data)
+
+API int preference_foreach_item(preference_item_cb callback, void *user_data)
{
- int ret;
- char *buf;
- char **result;
- int rows;
- int columns;
- char *errmsg;
- int i;
+ START_TIME_CHECK
- if (callback == NULL) {
- LOGE("INVALID_PARAMETER(0x%08x)",
- PREFERENCE_ERROR_INVALID_PARAMETER);
- return PREFERENCE_ERROR_INVALID_PARAMETER;
- }
+ retvm_if(callback == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: cb(%p)", callback);
- if (pref_db == NULL) {
- if (_initialize() != PREFERENCE_ERROR_NONE) {
- LOGE("IO_ERROR(0x%08x) : fail to initialize db",
- PREFERENCE_ERROR_IO_ERROR);
- return PREFERENCE_ERROR_IO_ERROR;
- }
- }
+ int ret = 0;
+ DIR *dir;
+ struct dirent *dent = NULL;
+ char *pref_dir_path = NULL;
- buf = sqlite3_mprintf("SELECT %s FROM %s;",
- PREF_F_KEY_NAME, PREF_TBL_NAME);
- if (buf == NULL) {
- LOGE("IO_ERROR(0x%08x) : fail to create query string",
- PREFERENCE_ERROR_IO_ERROR);
+ pref_dir_path = _preference_get_pref_dir_path();
+ if (!pref_dir_path)
+ {
+ LOGE("_preference_get_pref_dir_path() failed.");
return PREFERENCE_ERROR_IO_ERROR;
}
- ret = sqlite3_get_table(pref_db, buf, &result, &rows, &columns, &errmsg);
- sqlite3_free(buf);
- if (ret != SQLITE_OK) {
- LOGE("IO_ERROR(0x%08x) : fail to read data (%s)",
- PREFERENCE_ERROR_IO_ERROR, errmsg);
- sqlite3_free(errmsg);
+ dir = opendir(pref_dir_path);
+ if (dir == NULL)
+ {
+ LOGE("opendir() failed. path: %s, error: %d(%s)", pref_dir_path, errno, strerror(errno));
return PREFERENCE_ERROR_IO_ERROR;
}
- for (i = 1; i <= rows; i++) {
- if (callback(result[i], user_data) != true)
- break;
+ while((dent = readdir(dir)))
+ {
+ const char *entry = dent->d_name;
+ char keyname[PREFERENCE_KEY_PATH_LEN] = {0,};
+
+ if (entry[0] == '.')
+ {
+ continue;
+ }
+
+ ret = _preference_get_key_name(entry, keyname);
+ retv_if(ret != PREFERENCE_ERROR_NONE, ret);
+
+ callback(keyname, user_data);
}
- sqlite3_free_table(result);
+ closedir(dir);
+ END_TIME_CHECK
return PREFERENCE_ERROR_NONE;
}
--- /dev/null
+/*
+ * Copyright (c) 2015 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 <unistd.h>
+#include <string.h>
+#include <sqlite3.h>
+
+#include <app_internal.h>
+
+#include <app_preference.h>
+#include <app_preference_internal.h>
+
+#include <dlog.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+
+#define LOG_TAG "CAPI_APPFW_APPLICATION_PREFERENCE"
+#define DBG_MODE (1)
+
+static sqlite3 *pref_db = NULL;
+static bool is_update_hook_registered = false;
+static pref_changed_cb_node_t *head = NULL;
+
+static void _finish(void *data)
+{
+ if (pref_db != NULL)
+ {
+ sqlite3_close(pref_db);
+ pref_db = NULL;
+ }
+}
+
+static int _busy_handler(void *pData, int count)
+{
+ if(5 - count > 0) {
+ LOGD("Busy Handler Called! : PID(%d) / CNT(%d)\n", getpid(), count+1);
+ usleep((count+1)*100000);
+ return 1;
+ } else {
+ LOGD("Busy Handler will be returned SQLITE_BUSY error : PID(%d) \n", getpid());
+ return 0;
+ }
+}
+
+static int _initialize(void)
+{
+ char *data_path = NULL;
+ char db_path[TIZEN_PATH_MAX] = {0, };
+ int ret;
+ char *errmsg;
+
+ if ((data_path = app_get_data_path()) == NULL)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to get data directory", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ snprintf(db_path, sizeof(db_path), "%s/%s", data_path, PREF_DB_NAME);
+ free(data_path);
+
+ ret = sqlite3_open(db_path, &pref_db);
+ if (ret != SQLITE_OK)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to open db(%s)", PREFERENCE_ERROR_IO_ERROR, sqlite3_errmsg(pref_db));
+ pref_db = NULL;
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = sqlite3_busy_handler(pref_db, _busy_handler, NULL);
+ if (ret != SQLITE_OK) {
+ LOGW("IO_ERROR(0x%08x) : fail to register busy handler(%s)\n", PREFERENCE_ERROR_IO_ERROR, sqlite3_errmsg(pref_db));
+ }
+
+ ret = sqlite3_exec(pref_db, "CREATE TABLE IF NOT EXISTS pref ( pref_key TEXT PRIMARY KEY, pref_type TEXT, pref_data TEXT)",
+ NULL, NULL, &errmsg);
+ if (ret != SQLITE_OK)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to create db table(%s)", PREFERENCE_ERROR_IO_ERROR, errmsg);
+ sqlite3_free(errmsg);
+ sqlite3_close(pref_db);
+ pref_db = NULL;
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ app_finalizer_add(_finish, NULL);
+
+ return PREFERENCE_ERROR_NONE;
+}
+
+static int _write_data(const char *key, const char *type, const char *data)
+{
+ int ret;
+ char *buf = NULL;
+ bool exist = false;
+ sqlite3_stmt *stmt;
+
+ if (key == NULL || key[0] == '\0' || data == NULL)
+ {
+ LOGE("INVALID_PARAMETER(0x%08x)", PREFERENCE_ERROR_INVALID_PARAMETER);
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+
+ /* insert data or update data if data already exist */
+ ret = preference_is_existing(key, &exist);
+ if (ret != PREFERENCE_ERROR_NONE)
+ {
+ return ret;
+ }
+
+ // to use sqlite3_update_hook, we have to use INSERT/UPDATE operation instead of REPLACE operation
+ if (exist)
+ {
+ buf = sqlite3_mprintf("UPDATE %s SET %s=?, %s=? WHERE %s=?;",
+ PREF_TBL_NAME, PREF_F_TYPE_NAME, PREF_F_DATA_NAME, PREF_F_KEY_NAME);
+ }
+ else
+ {
+ buf = sqlite3_mprintf("INSERT INTO %s (%s, %s, %s) values (?, ?, ?);",
+ PREF_TBL_NAME, PREF_F_KEY_NAME, PREF_F_TYPE_NAME, PREF_F_DATA_NAME);
+ }
+
+ if (buf == NULL)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to create query string", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = sqlite3_prepare(pref_db, buf, strlen(buf), &stmt, NULL);
+ if (ret != SQLITE_OK) {
+ LOGE("IO_ERROR(0x%08x) : fail to prepare query (%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ if(exist)
+ {
+ ret = sqlite3_bind_text(stmt, 1, type, strlen(type), SQLITE_STATIC);
+ if(ret != SQLITE_OK) {
+ LOGE("IO_ERROR(0x%08x) : fail to bind(1) query (%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ sqlite3_finalize(stmt);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ ret = sqlite3_bind_text(stmt, 2, data, strlen(data), SQLITE_STATIC);
+ if(ret != SQLITE_OK) {
+ LOGE("IO_ERROR(0x%08x) : fail to bind(2) query (%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ sqlite3_finalize(stmt);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ ret = sqlite3_bind_text(stmt, 3, key, strlen(key), SQLITE_STATIC);
+ if(ret != SQLITE_OK) {
+ LOGE("IO_ERROR(0x%08x) : fail to bind(3) query (%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ sqlite3_finalize(stmt);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ }
+ else
+ {
+ ret = sqlite3_bind_text(stmt, 1, key, strlen(key), SQLITE_STATIC);
+ if(ret != SQLITE_OK) {
+ LOGE("IO_ERROR(0x%08x) : fail to bind(1) query (%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ sqlite3_finalize(stmt);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ ret = sqlite3_bind_text(stmt, 2, type, strlen(type), SQLITE_STATIC);
+ if(ret != SQLITE_OK) {
+ LOGE("IO_ERROR(0x%08x) : fail to bind(2) query (%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ sqlite3_finalize(stmt);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ ret = sqlite3_bind_text(stmt, 3, data, strlen(data), SQLITE_STATIC);
+ if(ret != SQLITE_OK) {
+ LOGE("IO_ERROR(0x%08x) : fail to bind(3) query (%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ sqlite3_finalize(stmt);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ }
+
+ ret = sqlite3_step(stmt);
+ if (ret != SQLITE_DONE) {
+ LOGE("IO_ERROR(0x%08x): fail to write data(%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ sqlite3_finalize(stmt);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ sqlite3_finalize(stmt);
+ if(buf) {
+ sqlite3_free(buf);
+ buf = NULL;
+ }
+
+ return PREFERENCE_ERROR_NONE;
+}
+
+//static int _read_data(const char *key, preference_type_e *type, char *data)
+static int _read_data(const char *key, char *type, char *data)
+{
+ int ret;
+ char *buf;
+ char **result;
+ int rows;
+ int columns;
+ char *errmsg;
+
+ if (key == NULL || key[0] == '\0' || data == NULL)
+ {
+ LOGE("INVALID_PARAMETER(0x%08x)", PREFERENCE_ERROR_INVALID_PARAMETER);
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+
+ if (pref_db == NULL)
+ {
+ if (_initialize() != PREFERENCE_ERROR_NONE)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to initialize db", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ }
+
+ buf = sqlite3_mprintf("SELECT %s, %s, %s FROM %s WHERE %s=%Q;",
+ PREF_F_KEY_NAME, PREF_F_TYPE_NAME, PREF_F_DATA_NAME, PREF_TBL_NAME, PREF_F_KEY_NAME, key);
+
+ if (buf == NULL)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to create query string", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = sqlite3_get_table(pref_db, buf, &result, &rows, &columns, &errmsg);
+ sqlite3_free(buf);
+ if (ret != SQLITE_OK)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to read data (%s)", PREFERENCE_ERROR_IO_ERROR, errmsg);
+ sqlite3_free(errmsg);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ if (rows == 0)
+ {
+ LOGE("NO_KEY(0x%08x) : fail to find given key(%s)", PREFERENCE_ERROR_NO_KEY, key);
+ sqlite3_free_table(result);
+ return PREFERENCE_ERROR_NO_KEY;
+ }
+
+ snprintf(type, 2, "%s", result[4]); // get type value
+ snprintf(data, BUF_LEN, "%s", result[5]); // get data value
+
+ sqlite3_free_table(result);
+
+ return PREFERENCE_ERROR_NONE;
+}
+
+
+int preference_set_int(const char *key, int value)
+{
+ char type[2];
+ char data[BUF_LEN];
+ snprintf(type, 2, "%d", PREFERENCE_TYPE_INT);
+ snprintf(data, BUF_LEN, "%d", value);
+ return _write_data(key, type, data);
+}
+
+int preference_get_int(const char *key, int *value)
+{
+ char type[2];
+ char data[BUF_LEN];
+ int ret;
+
+ if (value == NULL) {
+ LOGE("INVALID_PARAMETER(0x%08x)", PREFERENCE_ERROR_INVALID_PARAMETER);
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _read_data(key, type, data);
+ if (ret == PREFERENCE_ERROR_NONE)
+ {
+ if (atoi(type) == PREFERENCE_TYPE_INT)
+ {
+ *value = atoi(data);
+ }
+ else
+ {
+ LOGE("INVALID_PARAMETER(0x%08x) : param type(%d)", PREFERENCE_ERROR_INVALID_PARAMETER, atoi(type));
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+ }
+
+ return ret;
+}
+
+int preference_set_double(const char *key, double value)
+{
+ char type[2];
+ char data[BUF_LEN];
+
+ locale_t loc = newlocale(LC_NUMERIC_MASK, "C", NULL);
+ uselocale(loc);
+
+ snprintf(type, 2, "%d", PREFERENCE_TYPE_DOUBLE);
+ snprintf(data, BUF_LEN, "%f", value);
+
+ freelocale(loc);
+ uselocale(LC_GLOBAL_LOCALE);
+
+ return _write_data(key, type, data);
+}
+
+int preference_get_double(const char *key, double *value)
+{
+ char type[2];
+ char data[BUF_LEN];
+
+ int ret;
+
+ if (value == NULL) {
+ LOGE("INVALID_PARAMETER(0x%08x)", PREFERENCE_ERROR_INVALID_PARAMETER);
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _read_data(key, type, data);
+ if (ret == PREFERENCE_ERROR_NONE)
+ {
+ if (atoi(type) == PREFERENCE_TYPE_DOUBLE)
+ {
+ locale_t loc = newlocale(LC_NUMERIC_MASK, "C", NULL);
+ uselocale(loc);
+
+ *value = atof(data);
+
+ freelocale(loc);
+ uselocale(LC_GLOBAL_LOCALE);
+ }
+ else
+ {
+ LOGE("INVALID_PARAMETER(0x%08x) : param type(%d)", PREFERENCE_ERROR_INVALID_PARAMETER, atoi(type));
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+ }
+
+ return ret;
+}
+
+int preference_set_string(const char *key, const char *value)
+{
+ char type[2];
+
+ snprintf(type, 2, "%d", PREFERENCE_TYPE_STRING);
+ if (strlen(value) > (BUF_LEN-1))
+ {
+ LOGE("INVALID_PARAMETER(0x%08x) : param type(%d)", PREFERENCE_ERROR_INVALID_PARAMETER, atoi(type));
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+ return _write_data(key, type, value);
+}
+
+int preference_get_string(const char *key, char **value)
+{
+ char type[2];
+ char data[BUF_LEN];
+
+ int ret;
+
+ if (value == NULL)
+ {
+ LOGE("INVALID_PARAMETER(0x%08x)", PREFERENCE_ERROR_INVALID_PARAMETER);
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _read_data(key, type, data);
+ if (ret == PREFERENCE_ERROR_NONE)
+ {
+ if (atoi(type) == PREFERENCE_TYPE_STRING)
+ {
+ *value = strdup(data);
+ if (value == NULL)
+ {
+ LOGE("OUT_OF_MEMORY(0x%08x)", PREFERENCE_ERROR_OUT_OF_MEMORY);
+ return PREFERENCE_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ LOGE("INVALID_PARAMETER(0x%08x) : param type(%d)", PREFERENCE_ERROR_INVALID_PARAMETER, atoi(type));
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+ }
+
+ return ret;
+}
+
+int preference_set_boolean(const char *key, bool value)
+{
+ char type[2];
+ char data[BUF_LEN];
+ snprintf(type, 2, "%d", PREFERENCE_TYPE_BOOLEAN);
+ snprintf(data, BUF_LEN, "%d", value);
+ return _write_data(key, type, data);
+}
+
+int preference_get_boolean(const char *key, bool *value)
+{
+ char type[2];
+ char data[BUF_LEN];
+
+ int ret;
+
+ if (value == NULL) {
+ LOGE("INVALID_PARAMETER(0x%08x)", PREFERENCE_ERROR_INVALID_PARAMETER);
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _read_data(key, type, data);
+ if (ret == PREFERENCE_ERROR_NONE)
+ {
+ if (atoi(type) == PREFERENCE_TYPE_BOOLEAN)
+ {
+ *value = (bool)atoi(data);
+ }
+ else
+ {
+ LOGE("INVALID_PARAMETER(0x%08x) : param type(%d)", PREFERENCE_ERROR_INVALID_PARAMETER, atoi(type));
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+ }
+
+ return ret;
+}
+
+
+// TODO: below operation is too heavy, let's find the light way to check.
+int preference_is_existing(const char *key, bool *exist)
+{
+ int ret;
+ char *buf;
+ char **result;
+ int rows;
+ int columns;
+ char *errmsg;
+
+ if (key == NULL || key[0] == '\0' || exist == NULL)
+ {
+ LOGE("INVALID_PARAMETER(0x%08x)", PREFERENCE_ERROR_INVALID_PARAMETER);
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+
+ if (pref_db == NULL)
+ {
+ if (_initialize() != PREFERENCE_ERROR_NONE)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to initialize db", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ }
+
+ /* check data is exist */
+ buf = sqlite3_mprintf("SELECT %s FROM %s WHERE %s=%Q;", PREF_F_KEY_NAME, PREF_TBL_NAME, PREF_F_KEY_NAME, key);
+
+ if (buf == NULL)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to create query string", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = sqlite3_get_table(pref_db, buf, &result, &rows, &columns, &errmsg);
+ sqlite3_free(buf);
+ if (ret != SQLITE_OK)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to read data(%s)", PREFERENCE_ERROR_IO_ERROR, errmsg);
+ sqlite3_free(errmsg);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ if (rows > 0)
+ {
+ *exist = true;
+ }
+ else
+ {
+ *exist = false;
+ }
+
+ sqlite3_free_table(result);
+ return PREFERENCE_ERROR_NONE;
+}
+
+static pref_changed_cb_node_t* _find_node(const char *key)
+{
+ pref_changed_cb_node_t *tmp_node;
+
+ if (key == NULL || key[0] == '\0' )
+ {
+ return NULL;
+ }
+
+ tmp_node = head;
+
+ while (tmp_node)
+ {
+ if (strcmp(tmp_node->key, key) == 0)
+ {
+ break;
+ }
+ tmp_node = tmp_node->next;
+ }
+
+ return tmp_node;
+}
+
+
+static int _add_node(const char *key, preference_changed_cb cb, void *user_data)
+{
+ pref_changed_cb_node_t *tmp_node;
+
+ if (key == NULL || key[0] == '\0' || cb == NULL)
+ {
+ LOGE("INVALID_PARAMETER(0x%08x)", PREFERENCE_ERROR_INVALID_PARAMETER);
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+
+ tmp_node = _find_node(key);
+
+ if (tmp_node != NULL)
+ {
+ tmp_node->cb = cb;
+ tmp_node->user_data = user_data;
+ }
+ else
+ {
+ tmp_node = (pref_changed_cb_node_t*)malloc(sizeof(pref_changed_cb_node_t));
+ if (tmp_node == NULL)
+ {
+ LOGE("OUT_OF_MEMORY(0x%08x)", PREFERENCE_ERROR_OUT_OF_MEMORY);
+ return PREFERENCE_ERROR_OUT_OF_MEMORY;
+ }
+
+ tmp_node->key = strdup(key);
+ if (tmp_node->key == NULL)
+ {
+ free(tmp_node);
+ LOGE("OUT_OF_MEMORY(0x%08x)", PREFERENCE_ERROR_OUT_OF_MEMORY);
+ return PREFERENCE_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (head != NULL)
+ head->prev = tmp_node;
+ tmp_node->cb = cb;
+ tmp_node->user_data = user_data;
+ tmp_node->prev = NULL;
+ tmp_node->next = head;
+ head = tmp_node;
+ }
+
+ return PREFERENCE_ERROR_NONE;
+}
+
+static int _remove_node(const char *key)
+{
+ pref_changed_cb_node_t *tmp_node;
+
+ if (key == NULL || key[0] == '\0' )
+ {
+ LOGE("INVALID_PARAMETER(0x%08x)", PREFERENCE_ERROR_INVALID_PARAMETER);
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+
+ tmp_node = _find_node(key);
+
+ if (tmp_node == NULL)
+ {
+ return PREFERENCE_ERROR_NONE;
+ }
+
+ if (tmp_node->prev != NULL)
+ {
+ tmp_node->prev->next = tmp_node->next;
+ }
+ else
+ {
+ head = tmp_node->next;
+ }
+
+ if (tmp_node->next != NULL)
+ {
+ tmp_node->next->prev = tmp_node->prev;
+ }
+
+ if (tmp_node->key)
+ {
+ free(tmp_node->key);
+ }
+
+ free(tmp_node);
+
+ return PREFERENCE_ERROR_NONE;
+}
+
+
+static void _remove_all_node(void)
+{
+ pref_changed_cb_node_t *tmp_node;
+
+ while (head)
+ {
+ tmp_node = head;
+ head = tmp_node->next;
+
+ if (tmp_node->key)
+ {
+ free(tmp_node->key);
+ }
+
+ free(tmp_node);
+ }
+}
+
+
+static void _update_cb(void *data, int action, char const *db_name, char const *table_name, sqlite_int64 rowid)
+{
+ int ret;
+ char *buf;
+ char **result;
+ int rows;
+ int columns;
+ char *errmsg;
+ pref_changed_cb_node_t *tmp_node;
+
+ // skip INSERT/DELETE event
+ if (action != SQLITE_UPDATE)
+ {
+ return;
+ }
+
+ if (strcmp(table_name, PREF_TBL_NAME) != 0)
+ {
+ SECURE_LOGE("given table name (%s) is not same", table_name);
+ return;
+ }
+
+ buf = sqlite3_mprintf("SELECT %s FROM %s WHERE rowid='%lld';", PREF_F_KEY_NAME, PREF_TBL_NAME, rowid);
+ if (buf == NULL)
+ {
+ return;
+ }
+ ret = sqlite3_get_table(pref_db, buf, &result, &rows, &columns, &errmsg);
+ sqlite3_free(buf);
+ if (ret != SQLITE_OK)
+ {
+ LOGI("fail to read data(%s)", errmsg);
+ sqlite3_free(errmsg);
+ return;
+ }
+
+ if (rows == 0)
+ {
+ sqlite3_free_table(result);
+ return;
+ }
+
+ tmp_node = _find_node(result[1]);
+
+ if (tmp_node != NULL && tmp_node->cb != NULL)
+ {
+ tmp_node->cb(result[1], tmp_node->user_data);
+ }
+
+ sqlite3_free_table(result);
+}
+
+
+int preference_remove(const char *key)
+{
+ int ret;
+ char *buf;
+ bool exist;
+ sqlite3_stmt *stmt;
+
+ ret = preference_is_existing(key, &exist);
+ if (ret != PREFERENCE_ERROR_NONE)
+ {
+ return ret;
+ }
+
+ if (!exist)
+ {
+ return PREFERENCE_ERROR_NO_KEY;
+ }
+
+ /* insert data or update data if data already exist */
+ buf = sqlite3_mprintf("DELETE FROM %s WHERE %s = ?",
+ PREF_TBL_NAME, PREF_F_KEY_NAME, key);
+ if (buf == NULL)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to create query string", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = sqlite3_prepare(pref_db, buf, strlen(buf), &stmt, NULL);
+ if (ret != SQLITE_OK) {
+ LOGE("IO_ERROR(0x%08x) : fail to prepare query (%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = sqlite3_bind_text(stmt, 1, key, strlen(key), SQLITE_STATIC);
+ if(ret != SQLITE_OK) {
+ LOGE("IO_ERROR(0x%08x) : fail to bind(1) query (%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ sqlite3_finalize(stmt);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = sqlite3_step(stmt);
+ if (ret != SQLITE_DONE) {
+ LOGE("IO_ERROR(0x%08x): fail to delete data(%d/%s)",
+ PREFERENCE_ERROR_IO_ERROR,
+ sqlite3_extended_errcode(pref_db),
+ sqlite3_errmsg(pref_db));
+ sqlite3_finalize(stmt);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ sqlite3_finalize(stmt);
+ if(buf) {
+ sqlite3_free(buf);
+ buf = NULL;
+ }
+
+ // if exist, remove changed cb
+ _remove_node(key);
+
+ return PREFERENCE_ERROR_NONE;
+}
+
+
+int preference_remove_all(void)
+{
+ int ret;
+ char *buf;
+ char *errmsg;
+
+ if (pref_db == NULL)
+ {
+ if (_initialize() != PREFERENCE_ERROR_NONE)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to initialize db", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ }
+
+ /* insert data or update data if data already exist */
+ buf = sqlite3_mprintf("DELETE FROM %s;", PREF_TBL_NAME);
+ if (buf == NULL)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to create query string", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = sqlite3_exec(pref_db, buf, NULL, NULL, &errmsg);
+ sqlite3_free(buf);
+ if (ret != SQLITE_OK)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to delete data (%s)", PREFERENCE_ERROR_IO_ERROR, errmsg);
+ sqlite3_free(errmsg);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ // if exist, remove changed cb
+ _remove_all_node();
+
+ return PREFERENCE_ERROR_NONE;
+}
+
+
+int preference_set_changed_cb(const char *key, preference_changed_cb callback, void *user_data)
+{
+ int ret;
+ bool exist;
+
+ ret = preference_is_existing(key, &exist);
+ if (ret != PREFERENCE_ERROR_NONE)
+ {
+ return ret;
+ }
+
+ if (!exist)
+ {
+ LOGE("NO_KEY(0x%08x) : fail to find given key(%s)", PREFERENCE_ERROR_NO_KEY, key);
+ return PREFERENCE_ERROR_NO_KEY;
+ }
+
+ if (!is_update_hook_registered)
+ {
+ sqlite3_update_hook(pref_db, _update_cb, NULL);
+ is_update_hook_registered = true;
+ }
+
+ return _add_node(key, callback, user_data);
+}
+
+int preference_unset_changed_cb(const char *key)
+{
+ int ret;
+ bool exist;
+
+ ret = preference_is_existing(key, &exist);
+ if (ret != PREFERENCE_ERROR_NONE)
+ {
+ return ret;
+ }
+
+ if (!exist)
+ {
+ LOGE("NO_KEY(0x%08x) : fail to find given key(%s)", PREFERENCE_ERROR_NO_KEY, key);
+ return PREFERENCE_ERROR_NO_KEY;
+ }
+
+ return _remove_node(key);
+}
+
+int preference_foreach_item(preference_item_cb callback, void *user_data)
+{
+ int ret;
+ char *buf;
+ char **result;
+ int rows;
+ int columns;
+ char *errmsg;
+ int i;
+
+ if (callback == NULL)
+ {
+ LOGE("INVALID_PARAMETER(0x%08x)", PREFERENCE_ERROR_INVALID_PARAMETER);
+ return PREFERENCE_ERROR_INVALID_PARAMETER;
+ }
+
+ if (pref_db == NULL)
+ {
+ if (_initialize() != PREFERENCE_ERROR_NONE)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to initialize db", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ }
+
+ buf = sqlite3_mprintf("SELECT %s FROM %s;", PREF_F_KEY_NAME, PREF_TBL_NAME);
+ if (buf == NULL)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to create query string", PREFERENCE_ERROR_IO_ERROR);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = sqlite3_get_table(pref_db, buf, &result, &rows, &columns, &errmsg);
+ sqlite3_free(buf);
+ if (ret != SQLITE_OK)
+ {
+ LOGE("IO_ERROR(0x%08x) : fail to read data (%s)", PREFERENCE_ERROR_IO_ERROR, errmsg);
+ sqlite3_free(errmsg);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ for (i = 1; i <= rows; i++)
+ {
+ if (callback(result[i], user_data) != true)
+ {
+ break;
+ }
+ }
+
+ sqlite3_free_table(result);
+
+ return PREFERENCE_ERROR_NONE;
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2015 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 <sys/types.h>
+#include <sys/inotify.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <linux/version.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <glib.h>
+
+#include <app_preference.h>
+#include <app_preference_internal.h>
+
+#include <glib.h>
+
+#define INOTY_EVENT_MASK (IN_CLOSE_WRITE | IN_DELETE_SELF)
+
+/* inotify */
+struct noti_node {
+ int wd;
+ char *keyname;
+ preference_changed_cb cb;
+ void *cb_data;
+ struct noti_node *next;
+};
+typedef struct noti_node noti_node_s;
+static GList *g_notilist;
+
+static int _preference_inoti_comp_with_wd(gconstpointer a, gconstpointer b)
+{
+ int r;
+
+ noti_node_s *key1 = (noti_node_s *) a;
+ noti_node_s *key2 = (noti_node_s *) b;
+
+ r = key1->wd - key2->wd;
+ return r;
+}
+
+static int _kdb_inoti_fd;
+
+static pthread_mutex_t _kdb_inoti_fd_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t _kdb_g_ns_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static GSource *_kdb_handler;
+
+static GList* _preference_copy_noti_list(GList *orig_notilist)
+{
+ GList *copy_notilist = NULL;
+ struct noti_node *n = NULL;
+ struct noti_node *t = NULL;
+
+ if (!orig_notilist)
+ return NULL;
+
+ orig_notilist = g_list_first(orig_notilist);
+ if (!orig_notilist)
+ return NULL;
+
+ while (orig_notilist) {
+ do {
+ t = orig_notilist->data;
+
+ if (t == NULL) {
+ WARN("noti item data is null");
+ break;
+ }
+
+ if ((t->keyname == NULL) || (strlen(t->keyname) == 0)) {
+ WARN("noti item data key name is null");
+ break;
+ }
+
+ n = calloc(1, sizeof(noti_node_s));
+ if (n == NULL) {
+ ERR("_preference_copy_noti_list : calloc failed. memory full");
+ break;
+ }
+
+ n->keyname = strndup(t->keyname, PREFERENCE_KEY_PATH_LEN);
+ if (n->keyname == NULL)
+ {
+ ERR("The memory is insufficient, errno: %d (%s)", errno, strerror(errno));
+ free(n);
+ break;
+ }
+ n->wd = t->wd;
+ n->cb_data = t->cb_data;
+ n->cb = t->cb;
+
+ copy_notilist = g_list_append(copy_notilist, n);
+ } while (0);
+
+ orig_notilist = g_list_next(orig_notilist);
+ }
+ return copy_notilist;
+}
+
+static void _preference_free_noti_node(gpointer data)
+{
+ struct noti_node *n = (struct noti_node*)data;
+ g_free(n->keyname);
+ g_free(n);
+}
+
+static void _preference_free_noti_list(GList *noti_list)
+{
+ g_list_free_full(noti_list, _preference_free_noti_node);
+}
+
+
+static gboolean _preference_kdb_gio_cb(GIOChannel *src, GIOCondition cond, gpointer data)
+{
+ int fd, r, res;
+ struct inotify_event ie;
+ GList *l_notilist = NULL;
+
+ fd = g_io_channel_unix_get_fd(src);
+ r = read(fd, &ie, sizeof(ie));
+
+ while (r > 0) {
+ if (ie.mask & INOTY_EVENT_MASK) {
+
+ INFO("read event from GIOChannel. wd : %d", ie.wd);
+
+ pthread_mutex_lock(&_kdb_g_ns_mutex);
+ l_notilist = _preference_copy_noti_list(g_notilist);
+ pthread_mutex_unlock(&_kdb_g_ns_mutex);
+
+ if (l_notilist) {
+
+ struct noti_node *t = NULL;
+ GList *noti_list = NULL;
+
+ noti_list = g_list_first(l_notilist);
+
+ while (noti_list) {
+ t = noti_list->data;
+
+ keynode_t* keynode = _preference_keynode_new();
+ if (keynode == NULL) {
+ ERR("key malloc fail");
+ break;
+ }
+
+ if ( (t) && (t->wd == ie.wd) && (t->keyname) ) {
+ if ((ie.mask & IN_DELETE_SELF))
+ {
+ res = _preference_kdb_del_notify(t->keyname);
+ if (res != PREFERENCE_ERROR_NONE)
+ ERR("_preference_kdb_del_notify() failed(%d)", res);
+ }
+ else
+ {
+ res = _preference_keynode_set_keyname(keynode, t->keyname);
+ if (res != PREFERENCE_ERROR_NONE) {
+ ERR("_preference_keynode_set_keyname() failed(%d)", res);
+ goto out_func;
+ }
+
+ res = _preference_get_key(keynode);
+ if (res != PREFERENCE_ERROR_NONE)
+ ERR("_preference_get_key() failed(%d)", res);
+
+ INFO("key(%s) is changed. cb(%p) called", t->keyname, t->cb);
+ t->cb(t->keyname, t->cb_data);
+ }
+ }
+ else if ( (t) && (t->keyname == NULL) ) { /* for debugging */
+ ERR("preference keyname is null.");
+ }
+out_func:
+ _preference_keynode_free(keynode);
+
+ noti_list = g_list_next(noti_list);
+ }
+
+ _preference_free_noti_list(l_notilist);
+ }
+ }
+
+ if (ie.len > 0)
+ (void) lseek(fd, ie.len, SEEK_CUR);
+
+ r = read(fd, &ie, sizeof(ie));
+ }
+ return TRUE;
+}
+
+static int _preference_kdb_noti_init(void)
+{
+ GIOChannel *gio;
+ int ret = 0;
+
+ pthread_mutex_lock(&_kdb_inoti_fd_mutex);
+
+ if (0 < _kdb_inoti_fd) {
+ ERR("Error: invalid _kdb_inoti_fd");
+ pthread_mutex_unlock(&_kdb_inoti_fd_mutex);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ _kdb_inoti_fd = inotify_init();
+ if (_kdb_inoti_fd == -1) {
+ char err_buf[100] = { 0, };
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ ERR("inotify init: %s", err_buf);
+ pthread_mutex_unlock(&_kdb_inoti_fd_mutex);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = fcntl(_kdb_inoti_fd, F_SETFD, FD_CLOEXEC);
+ if (ret < 0) {
+ char err_buf[100] = { 0, };
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ ERR("inotify init: %s", err_buf);
+ pthread_mutex_unlock(&_kdb_inoti_fd_mutex);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ ret = fcntl(_kdb_inoti_fd, F_SETFL, O_NONBLOCK);
+ if (ret < 0) {
+ char err_buf[100] = { 0, };
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ ERR("inotify init: %s", err_buf);
+ pthread_mutex_unlock(&_kdb_inoti_fd_mutex);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ pthread_mutex_unlock(&_kdb_inoti_fd_mutex);
+
+ gio = g_io_channel_unix_new(_kdb_inoti_fd);
+ retvm_if(gio == NULL, -1, "Error: create a new GIOChannel");
+
+ g_io_channel_set_flags(gio, G_IO_FLAG_NONBLOCK, NULL);
+
+ _kdb_handler = g_io_create_watch(gio, G_IO_IN);
+ g_source_set_callback(_kdb_handler, (GSourceFunc) _preference_kdb_gio_cb, NULL, NULL);
+ g_source_attach(_kdb_handler, NULL);
+ g_io_channel_unref(gio);
+ g_source_unref(_kdb_handler);
+
+ return PREFERENCE_ERROR_NONE;
+}
+
+int _preference_kdb_add_notify(const char *keyname, preference_changed_cb cb, void *data)
+{
+ char path[PREFERENCE_KEY_PATH_LEN];
+ int wd;
+ struct noti_node t, *n, *node;
+ char err_buf[ERR_LEN] = { 0, };
+ int ret = 0;
+ GList *list = NULL;
+ int func_ret = PREFERENCE_ERROR_NONE;
+
+ retvm_if((keyname == NULL || cb == NULL), PREFERENCE_ERROR_INVALID_PARAMETER,
+ "_preference_kdb_add_notify : Invalid argument - keyname(%s) cb(%p)",
+ keyname, cb);
+
+ if (_kdb_inoti_fd <= 0)
+ if (_preference_kdb_noti_init())
+ return PREFERENCE_ERROR_IO_ERROR;
+
+ ret = _preference_get_key_path((char*)keyname, path);
+ retvm_if(ret != PREFERENCE_ERROR_NONE, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is not valid");
+
+ if (0 != access(path, F_OK)) {
+ if (errno == ENOENT) {
+ ERR("_preference_kdb_add_notify : Key(%s) does not exist", keyname);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+ }
+
+ wd = inotify_add_watch(_kdb_inoti_fd, path, INOTY_EVENT_MASK);
+ if (wd == -1) {
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ ERR("_preference_kdb_add_notify : add noti(%s)", err_buf);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ t.wd = wd;
+
+ pthread_mutex_lock(&_kdb_g_ns_mutex);
+
+ list = g_list_find_custom(g_notilist, &t, (GCompareFunc)_preference_inoti_comp_with_wd);
+ if (list) {
+ WARN("_preference_kdb_add_notify : key(%s) change callback(%p)", keyname, cb);
+
+ node = list->data;
+ node->wd = wd;
+ node->cb_data = data;
+ node->cb = cb;
+
+ goto out_func;
+ }
+
+ n = calloc(1, sizeof(noti_node_s));
+ if (n == NULL) {
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ ERR("_preference_kdb_add_notify : add noti(%s)", err_buf);
+ func_ret = PREFERENCE_ERROR_IO_ERROR;
+ goto out_func;
+ }
+
+ n->keyname = strndup(keyname, PREFERENCE_KEY_PATH_LEN);
+ if (n->keyname == NULL)
+ {
+ ERR("The memory is insufficient, errno: %d (%s)", errno, strerror(errno));
+ free(n);
+ goto out_func;
+ }
+ n->wd = wd;
+ n->cb_data = data;
+ n->cb = cb;
+
+ g_notilist = g_list_append(g_notilist, n);
+ if (!g_notilist) {
+ ERR("g_list_append fail");
+ }
+
+ INFO("cb(%p) is added for %s. tot cb cnt : %d\n", cb, n->keyname, g_list_length(g_notilist));
+
+out_func:
+ pthread_mutex_unlock(&_kdb_g_ns_mutex);
+
+ return func_ret;
+}
+
+int _preference_kdb_del_notify(const char *keyname)
+{
+ int wd = 0;
+ int r = 0;
+ struct noti_node *n = NULL;
+ struct noti_node t;
+ char path[PREFERENCE_KEY_PATH_LEN] = { 0, };
+ char err_buf[ERR_LEN] = { 0, };
+ int del = 0;
+ int ret = 0;
+ int func_ret = PREFERENCE_ERROR_NONE;
+ GList *noti_list;
+
+ retvm_if(keyname == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: keyname(%s)", keyname);
+ retvm_if(_kdb_inoti_fd == 0, PREFERENCE_ERROR_NONE, "Invalid operation: not exist anything for inotify");
+
+ ret = _preference_get_key_path((char*)keyname, path);
+ retvm_if(ret != PREFERENCE_ERROR_NONE, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is not valid");
+
+ /* get wd */
+ wd = inotify_add_watch(_kdb_inoti_fd, path, INOTY_EVENT_MASK);
+ if (wd == -1) {
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ ERR("Error: inotify_add_watch() [%s]: %s", path, err_buf);
+ return PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ pthread_mutex_lock(&_kdb_g_ns_mutex);
+
+ t.wd = wd;
+
+ noti_list = g_list_find_custom(g_notilist, &t, (GCompareFunc)_preference_inoti_comp_with_wd);
+ if(noti_list) {
+ del++;
+
+ n = noti_list->data;
+ g_notilist = g_list_remove(g_notilist, n);
+ g_free(n->keyname);
+ g_free(n);
+
+ r = inotify_rm_watch(_kdb_inoti_fd, wd);
+ if(r == -1) {
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ ERR("Error: inotify_rm_watch [%s]: %s", keyname, err_buf);
+ func_ret = PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ INFO("key(%s) cb is removed. remained noti list total length(%d)",
+ keyname, g_list_length(g_notilist));
+ }
+
+ if(g_list_length(g_notilist) == 0) {
+ close(_kdb_inoti_fd);
+ _kdb_inoti_fd = 0;
+
+ g_source_destroy(_kdb_handler);
+ _kdb_handler = NULL;
+
+ g_list_free(g_notilist);
+ g_notilist = NULL;
+
+ INFO("all noti list is freed");
+ }
+
+ pthread_mutex_unlock(&_kdb_g_ns_mutex);
+
+ if(del == 0) {
+ errno = ENOENT;
+ func_ret = PREFERENCE_ERROR_IO_ERROR;
+ }
+
+ return func_ret;
+}
projects / platform / core / api / application.git / commitdiff