Tizen 2.1 base

1 files changed, 428 insertions, 0 deletions

diff --git a/native/ctsvc_utils.c b/native/ctsvc_utils.c
new file mode 100644
index 0000000..2fb1051
--- /dev/null
+++ b/native/ctsvc_utils.c
@@ -0,0 +1,428 @@
+/*
+ * Contacts Service
+ *
+ * Copyright (c) 2010 - 2012 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 <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/vfs.h>
+#include <image_util.h>
+
+#include "contacts.h"
+#include "ctsvc_internal.h"
+#include "ctsvc_utils.h"
+#include "ctsvc_mutex.h"
+#include "ctsvc_sqlite.h"
+#include "ctsvc_schema.h"
+#include "ctsvc_notification.h"
+#include "ctsvc_struct.h"
+
+#ifdef _CONTACTS_IPC_SERVER
+#include "ctsvc_server_change_subject.h"
+#endif
+
+static __thread int transaction_count = 0;
+static __thread int transaction_ver = 0;
+static __thread bool version_up = false;
+
+#define CTS_COMMIT_TRY_MAX 500000 // For 3second
+int ctsvc_begin_trans(void)
+{
+	int ret = -1, progress;
+
+#ifndef _CONTACTS_IPC_SERVER
+	ctsvc_mutex_lock(CTS_MUTEX_TRANSACTION);
+#endif
+	if (transaction_count <= 0) {
+		ret = ctsvc_query_exec("BEGIN IMMEDIATE TRANSACTION"); //taken 600ms
+		progress = 100000;
+		while (CONTACTS_ERROR_DB == ret && progress < CTS_COMMIT_TRY_MAX) {
+			usleep(progress);
+			ret = ctsvc_query_exec("BEGIN IMMEDIATE TRANSACTION");
+			progress *= 2;
+		}
+		if(CONTACTS_ERROR_NONE != ret) {
+			CTS_ERR("ctsvc_query_exec() Failed(%d)", ret);
+#ifndef _CONTACTS_IPC_SERVER
+			ctsvc_mutex_unlock(CTS_MUTEX_TRANSACTION);
+#endif
+			return ret;
+		}
+
+		transaction_count = 0;
+
+		const char *query = "SELECT ver FROM "CTS_TABLE_VERSION;
+		ret = ctsvc_query_get_first_int_result(query, &transaction_ver);
+		version_up = false;
+	}
+	transaction_count++;
+	INFO("transaction_count : %d.", transaction_count);
+#ifndef _CONTACTS_IPC_SERVER
+	ctsvc_mutex_unlock(CTS_MUTEX_TRANSACTION);
+#endif
+	return CONTACTS_ERROR_NONE;
+}
+
+int ctsvc_end_trans(bool is_success)
+{
+	int ret = -1, progress;
+	char query[CTS_SQL_MIN_LEN] = {0};
+
+#ifndef _CONTACTS_IPC_SERVER
+	ctsvc_mutex_lock(CTS_MUTEX_TRANSACTION);
+#endif
+
+	transaction_count--;
+	INFO("%s, transaction_count : %d", is_success?"True": "False",  transaction_count);
+
+	if (0 != transaction_count) {
+		CTS_DBG("contact transaction_count : %d.", transaction_count);
+#ifndef _CONTACTS_IPC_SERVER
+		ctsvc_mutex_unlock(CTS_MUTEX_TRANSACTION);
+#endif
+		return CONTACTS_ERROR_NONE;
+	}
+
+	if (false == is_success) {
+		ctsvc_nofitication_cancel();
+#ifdef _CONTACTS_IPC_SERVER
+		ctsvc_change_subject_clear_changed_info();
+#endif
+		ret = ctsvc_query_exec("ROLLBACK TRANSACTION");
+
+#ifndef _CONTACTS_IPC_SERVER
+		ctsvc_mutex_unlock(CTS_MUTEX_TRANSACTION);
+#endif
+		return CONTACTS_ERROR_NONE;
+	}
+
+	if (version_up) {
+		transaction_ver++;
+		snprintf(query, sizeof(query), "UPDATE %s SET ver = %d",
+				CTS_TABLE_VERSION, transaction_ver);
+		ret = ctsvc_query_exec(query);
+		WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_query_exec(version up) Failed(%d)", ret);
+	}
+
+	progress = 100000;
+	ret = ctsvc_query_exec("COMMIT TRANSACTION");
+	while (CONTACTS_ERROR_DB == ret && progress<CTS_COMMIT_TRY_MAX) {
+		usleep(progress);
+		ret = ctsvc_query_exec("COMMIT TRANSACTION");
+		progress *= 2;
+	}
+	if (CONTACTS_ERROR_NONE != ret) {
+		int tmp_ret;
+		CTS_ERR("ctsvc_query_exec() Failed(%d)", ret);
+		ctsvc_nofitication_cancel();
+#ifdef _CONTACTS_IPC_SERVER
+		ctsvc_change_subject_clear_changed_info();
+#endif
+		tmp_ret = ctsvc_query_exec("ROLLBACK TRANSACTION");
+		WARN_IF(CONTACTS_ERROR_NONE != tmp_ret, "ctsvc_query_exec(ROLLBACK) Failed(%d)", tmp_ret);
+#ifndef _CONTACTS_IPC_SERVER
+		ctsvc_mutex_unlock(CTS_MUTEX_TRANSACTION);
+#endif
+		return ret;
+	}
+
+
+	ctsvc_notification_send();
+#ifdef _CONTACTS_IPC_SERVER
+	ctsvc_change_subject_publish_changed_info();
+#endif
+
+#ifndef _CONTACTS_IPC_SERVER
+	ctsvc_mutex_unlock(CTS_MUTEX_TRANSACTION);
+#endif
+
+
+	CTS_DBG("Transaction shut down! : (%d)\n", transaction_ver);
+
+	return CONTACTS_ERROR_NONE;
+}
+
+const char* ctsvc_get_display_column(void)
+{
+	contacts_name_display_order_e order;
+
+	contacts_setting_get_name_display_order(&order);
+	if (CONTACTS_NAME_DISPLAY_ORDER_FIRSTLAST == order)
+		return "display_name";
+	else
+		return "reverse_display_name";
+}
+
+const char* ctsvc_get_sort_column(void)
+{
+	contacts_name_display_order_e order;
+
+	contacts_setting_get_name_display_order(&order);
+	if (CONTACTS_NAME_DISPLAY_ORDER_FIRSTLAST == order)
+		return "display_name_language, sortkey";
+	else
+		return "display_name_language, reverse_sortkey";
+}
+
+// This function is for MY profile and group image.
+char* ctsvc_get_image(const char *dir, int index, char *dest, int dest_size)
+{
+	DIR *dp;
+	char *ret_val;
+	struct dirent *file_info;
+	char tmp_path[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
+
+	if (0 < index)
+		snprintf(tmp_path, sizeof(tmp_path), "%d", index);
+
+	dp = opendir(dir);
+	if (dp) {
+		while ((file_info = readdir(dp)) != NULL) {
+			CTS_DBG("file = %s", file_info->d_name);
+			if ('.' != *file_info->d_name) {
+				if (0 == index || !strncmp(tmp_path, file_info->d_name, strlen(tmp_path))) {
+					if (dest) {
+						snprintf(dest, dest_size, "%s/%s", dir, file_info->d_name);
+						ret_val = dest;
+					} else {
+						snprintf(tmp_path, sizeof(tmp_path), "%s/%s", dir, file_info->d_name);
+						ret_val = strdup(tmp_path);
+					}
+					closedir(dp);
+					return ret_val;
+				}
+			}
+		}
+		closedir(dp);
+	}
+
+	return NULL;
+}
+
+static inline bool ctsvc_check_available_image_space(void){
+	int ret;
+	struct statfs buf;
+	long long size;
+	ret = statfs(CTS_IMG_FULL_LOCATION, &buf);
+
+	RETVM_IF(ret!=0, false, "statfs Failed(%d)", ret);
+
+	size = buf.f_bavail * (buf.f_bsize);
+
+	if (size > 1024*1024) // if available space to copy a image is larger than 1M
+		return true;
+	return false;
+}
+
+static int image_size = 480;
+static int __ctsvc_resize_and_copy_image(const char *src, const char *dest)
+{
+	image_util_error_e ret;
+	int width = 0, height = 0;
+	unsigned int size_decode = 0;
+	int resized_width, resized_height;
+	unsigned char * img_target = 0;
+	unsigned char * img_source = 0;
+	const image_util_colorspace_e colorspace = IMAGE_UTIL_COLORSPACE_I420;
+
+	// load jpeg sample file
+	CTS_DBG("src : %s, dest : %s", src, dest);
+	ret = image_util_decode_jpeg( src, colorspace, &img_source, &width, &height, &size_decode );
+	RETVM_IF(ret!=IMAGE_UTIL_ERROR_NONE, CONTACTS_ERROR_INTERNAL, "image_util_decode_jpeg failed(%d)", ret);
+
+#if 0
+	if (0>image_size) {
+		int w,h;
+		ecore_x_window_size_get(
+				ecore_x_window_root_get(ecore_x_window_focus_get())
+				, &w, &h);
+
+		if (w>h)
+			image_size = h;
+		else
+			image_size = w;
+
+	}
+#endif
+
+	if (width > image_size || height > image_size) {
+		if (image_size<=0 || width <=0 || height <= 0) {
+			free(img_source);
+			CTS_ERR("image size error(%d)", image_size);
+			return CONTACTS_ERROR_INTERNAL;
+		}
+
+		if (width>height) {
+			resized_width = image_size;
+			resized_height = height*image_size/width;
+		}
+		else {
+			resized_height = image_size;
+			resized_width = width*image_size/height;
+		}
+		CTS_DBG("size(%d, %d) -> resize(%d,%d)", width, height, resized_width, resized_height);
+
+		image_util_calculate_buffer_size(resized_width, resized_height, colorspace , &size_decode);
+
+		img_target = malloc( size_decode );
+		// do resize
+		ret = image_util_resize( img_target, &resized_width, &resized_height,
+				img_source, width, height, colorspace );
+		if (ret!=IMAGE_UTIL_ERROR_NONE) {
+			CTS_ERR("image_util_resize failed(%d)", ret);
+			free( img_target );
+			free( img_source );
+			return CONTACTS_ERROR_INTERNAL;
+		}
+
+		ret = image_util_encode_jpeg(img_target, resized_width, resized_height, colorspace, 100, dest );
+		free( img_target );
+		free( img_source );
+		RETVM_IF(ret!=IMAGE_UTIL_ERROR_NONE, CONTACTS_ERROR_INTERNAL, "image_util_encode_jpeg failed(%d)", ret);
+	}
+	else {
+		resized_width = width;
+		resized_height = height;
+
+		ret = image_util_encode_jpeg(img_source, resized_width, resized_height, colorspace, 100, dest );
+		free( img_source );
+		RETVM_IF(ret!=IMAGE_UTIL_ERROR_NONE, CONTACTS_ERROR_INTERNAL, "image_util_encode_jpeg failed(%d)", ret);
+	}
+
+	return CONTACTS_ERROR_NONE;
+}
+
+#define CTSVC_COPY_SIZE_MAX 4096
+int ctsvc_copy_image(const char *src, const char *dest)
+{
+	int ret;
+	int size;
+	int src_fd, dest_fd;
+	char buf[CTSVC_COPY_SIZE_MAX] = {0};
+
+	if (!ctsvc_check_available_image_space())
+		return CONTACTS_ERROR_FILE_NO_SPACE;
+
+	ret = __ctsvc_resize_and_copy_image(src, dest);
+	if (CONTACTS_ERROR_NONE == ret)
+		return ret;
+
+	src_fd = open(src, O_RDONLY);
+	RETVM_IF(src_fd < 0, CONTACTS_ERROR_SYSTEM, "System : Open(src:%s) Failed(%d)", src, errno);
+	dest_fd = open(dest, O_WRONLY|O_CREAT|O_TRUNC, 0660);
+	if (dest_fd < 0) {
+		CTS_ERR("Open(dest:%s) Failed(%d)", dest, errno);
+		close(src_fd);
+		return CONTACTS_ERROR_SYSTEM;
+	}
+
+	while ((size = read(src_fd, buf, CTSVC_COPY_SIZE_MAX)) > 0) {
+		ret = write(dest_fd, buf, size);
+		if (ret <= 0) {
+			if (EINTR == errno)
+				continue;
+			else {
+				CTS_ERR("write() Failed(%d)", errno);
+				if (ENOSPC == errno)
+					ret = CONTACTS_ERROR_SYSTEM;			// No space
+				else
+					ret = CONTACTS_ERROR_SYSTEM;			// IO error
+				close(src_fd);
+				close(dest_fd);
+				unlink(dest);
+				return ret;
+			}
+		}
+	}
+
+	ret = fchown(dest_fd, getuid(), CTS_SECURITY_FILE_GROUP);
+	if (0 != ret)
+		CTS_ERR("fchown(%s) Failed(%d)", dest, ret);
+	ret = fchmod(dest_fd, CTS_SECURITY_DEFAULT_PERMISSION);
+	if (0 != ret)
+		CTS_ERR("fchmod(%s) Failed(%d)", dest, ret);
+	close(src_fd);
+	close(dest_fd);
+
+	return CONTACTS_ERROR_NONE;
+}
+
+int ctsvc_change_image(const char *dir, int index, const char *path, char *image, int image_len)
+{
+	int ret;
+	char dest[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
+
+	if (ctsvc_get_image(dir, index, dest, sizeof(dest))) {
+		if (path && 0 == strcmp(dest, path))
+			return CONTACTS_ERROR_NONE;
+		ret = unlink(dest);
+		RETVM_IF(ret < 0, CONTACTS_ERROR_SYSTEM, "System : unlink(%s) Failed(%d)", dest, errno);
+	}
+
+	if (path) {
+		char *ext;
+		int len;
+		ext = strrchr(path, '.');
+		if (NULL == ext || strchr(ext, '/'))
+			ext = "";
+
+		snprintf(dest, sizeof(dest), "%s/%d%s",
+				dir, index, ext);
+		ret = ctsvc_copy_image(path, dest);
+		RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_copy_image() Failed(%d)", ret);
+		len = strlen(dest) - strlen(dir);
+		if (image_len < len) {
+			CTS_ERR("The image_len is too short. It should be greater than %d", len);
+			return CONTACTS_ERROR_INVALID_PARAMETER;
+		}
+		snprintf(image, image_len, "%d%s", index, ext);
+	}
+
+	return CONTACTS_ERROR_NONE;
+}
+
+int ctsvc_get_next_ver(void)
+{
+	const char *query;
+	int version;
+
+	if (0 < transaction_count) {
+		version_up = true;
+		return transaction_ver + 1;
+	}
+
+	query = "SELECT ver FROM "CTS_TABLE_VERSION;
+	ctsvc_query_get_first_int_result(query, &version);
+	return (1 + version);
+}
+
+int ctsvc_get_current_version( int* out_current_version ){
+	if (transaction_count <= 0) {
+		int ret;
+		int version = 0;
+		const char *query = "SELECT ver FROM "CTS_TABLE_VERSION;
+		ret = ctsvc_query_get_first_int_result(query, &version);
+		*out_current_version = version;
+	}
+	else
+		*out_current_version = transaction_ver;
+	return CONTACTS_ERROR_NONE;
+}
+
+