int mida_delete_with_pkgname(const char *pkg_name)
{
int rc = 0;
retvm_if(pkg_name == NULL, -1,
"Invalid argument: data to delete is NULL\n");
if (_init() < 0)
return -1;
rc = __delete_with_field(MIDA_TBL_NAME, MIDA_F_PKGNAME, pkg_name, 1);
__fini();
return rc;
}
int mida_delete_with_mimetype(const char *mime_type)
{
int rc = 0;
retvm_if(mime_type == NULL, -1,
"Invalid argument: data to delete is NULL\n");
if (_init() < 0)
return -1;
rc = __delete_with_field(MIDA_TBL_NAME, MIDA_F_MIMETYPE, mime_type, 0);
__fini();
return rc;
}
static inline int cts_merge_vcard_company(cts_company *orig, cts_company *addition)
{
bool temp;
retvm_if(NULL == addition, CTS_ERR_ARG_INVALID, "Invalid addition(%p)", addition);
CTS_VCARD_MOVE_TO(orig->name, addition->name, temp);
CTS_VCARD_MOVE_TO(orig->department, addition->department, temp);
CTS_VCARD_MOVE_TO(orig->jot_title, addition->jot_title, temp);
CTS_VCARD_MOVE_TO(orig->role, addition->role, temp);
CTS_VCARD_MOVE_TO(orig->assistant_name, addition->assistant_name, temp);
return CTS_SUCCESS;
}
static inline int cts_merge_vcard_base(cts_ct_base *orig, cts_ct_base *addition)
{
int ret;
char dest[CTS_IMG_PATH_SIZE_MAX];
retvm_if(NULL == addition, CTS_ERR_ARG_INVALID, "Invalid addition(%p)", addition);
if (NULL == orig->img_path) {
if (orig->id && addition->img_path) {
ret = snprintf(dest, sizeof(dest), "%s/%d-%d.", CTS_IMAGE_LOCATION,
orig->id, CTS_IMG_NORMAL);
if (0 != strncmp(dest, addition->img_path, ret)) {
orig->img_path = addition->img_path;
orig->img_changed = true;
addition->img_path = NULL;
}
} else {
orig->img_path = addition->img_path;
orig->img_changed = true;
addition->img_path = NULL;
}
}
if (NULL == orig->full_img_path) {
if (orig->id && addition->full_img_path) {
ret = snprintf(dest, sizeof(dest), "%s/%d-%d.", CTS_IMAGE_LOCATION,
orig->id, CTS_IMG_FULL);
if (0 != strncmp(dest, addition->full_img_path, ret)) {
orig->full_img_path = addition->full_img_path;
orig->full_img_changed = true;
addition->full_img_path = NULL;
}
} else {
orig->full_img_path = addition->full_img_path;
orig->full_img_changed = true;
addition->full_img_path = NULL;
}
}
CTS_VCARD_MOVE_TO(orig->uid, addition->uid, orig->uid_changed);
CTS_VCARD_MOVE_TO(orig->note, addition->note, orig->note_changed);
CTS_VCARD_MOVE_TO(orig->ringtone_path, addition->ringtone_path, orig->ringtone_changed);
if (NULL == orig->vcard_img_path) {
orig->vcard_img_path = addition->vcard_img_path;
addition->vcard_img_path = NULL;
}
return CTS_SUCCESS;
}
static inline cts_number* cts_struct_dup_number(const cts_number *src)
{
cts_number *result = NULL;
if (src) {
result = calloc(1, sizeof(cts_number));
retvm_if(NULL == result, NULL, "calloc() Failed");
memcpy(result, src, sizeof(cts_number));
if (src->number)
result->number = strdup(src->number);
}
return result;
}
static inline cts_email* cts_struct_dup_email(const cts_email *src)
{
cts_email *result = NULL;
if (src) {
result = calloc(1, sizeof(cts_email));
retvm_if(NULL == result, NULL, "calloc() Failed");
memcpy(result, src, sizeof(cts_email));
if (src->email_addr)
result->email_addr = strdup(src->email_addr);
}
return result;
}
static inline cts_web* cts_struct_dup_web(const cts_web *src)
{
cts_web *result = NULL;
if (src) {
result = calloc(1, sizeof(cts_web));
retvm_if(NULL == result, NULL, "calloc() Failed");
memcpy(result, src, sizeof(cts_web));
if (src->url)
result->url = strdup(src->url);
}
return result;
}
static inline cts_nickname* cts_struct_dup_nick(const cts_nickname *src)
{
cts_nickname *result = NULL;
if (src) {
result = calloc(1, sizeof(cts_nickname));
retvm_if(NULL == result, NULL, "calloc() Failed");
memcpy(result, src, sizeof(cts_nickname));
if (src->nick)
result->nick = strdup(src->nick);
}
return result;
}
static inline int cts_merge_vcard_name(cts_name *orig, cts_name *addition)
{
retvm_if(NULL == addition, CTS_ERR_ARG_INVALID, "Invalid addition(%p)", addition);
if (NULL == orig->first && NULL == orig->last) {
CTS_VCARD_MOVE_TO(orig->first, addition->first, orig->is_changed);
CTS_VCARD_MOVE_TO(orig->last, addition->last, orig->is_changed);
}
CTS_VCARD_MOVE_TO(orig->addition, addition->addition, orig->is_changed);
CTS_VCARD_MOVE_TO(orig->display, addition->display, orig->is_changed);
CTS_VCARD_MOVE_TO(orig->prefix, addition->prefix, orig->is_changed);
CTS_VCARD_MOVE_TO(orig->suffix, addition->suffix, orig->is_changed);
return CTS_SUCCESS;
}
ui_gadget_h create_button_ug(void *data)
{
ui_gadget_h ug = NULL;
struct ug_cbs cbs = {0};
struct appdata *ad = (struct appdata *)data;
retvm_if(ad == NULL, 0, "Invalid argument:appdata is NULL\n");
cbs.layout_cb = button_ug_layout_cb;
cbs.destroy_cb = button_ug_destroy_cb;
cbs.priv = (void *)data;
ecore_x_netwm_window_type_set(elm_win_xwindow_get(ad->win), ECORE_X_WINDOW_TYPE_NORMAL);
utilx_set_window_opaque_state(ecore_x_display_get(), elm_win_xwindow_get(ad->win), UTILX_OPAQUE_STATE_ON);
ug = ug_create(NULL, "setting-profile-efl", UG_MODE_FULLVIEW, NULL, &cbs);
return ug;
}
/**
* send
* This function is used to create blank
* @param parent[in] pointer to evas object, as the parent
* @param minw[in] Evas_Coord, as min width
* @param minh[in] Evas_Coord, as min height
* @return when success, return a pointer to evas object, or return NULL
* @exception
*/
Evas_Object *widget_create_rectangle_blank(Evas_Object * parent,
Evas_Object * parent_box,
Evas_Coord minw, Evas_Coord minh)
{
Evas_Object *rect;
//CLK_FUN_BEG();
rect = evas_object_rectangle_add(evas_object_evas_get(parent));
retvm_if(NULL_CHECK(rect), NULL, "rect null");
evas_object_size_hint_min_set(rect, minw, minh);
evas_object_size_hint_weight_set(rect, 0.0, 0.0);
evas_object_size_hint_align_set(rect, EVAS_HINT_FILL, EVAS_HINT_FILL);
evas_object_color_set(rect, 0, 0, 0, 0);
elm_box_pack_end(parent_box, rect);
evas_object_show(rect);
//CLK_FUN_END();
return rect;
}
extern "C" sensor_module* create(void)
{
pir_long_sensor *sensor;
try {
sensor = new(std::nothrow) pir_long_sensor;
} catch (int err) {
ERR("Failed to create module, err: %d, cause: %s", err, strerror(err));
return NULL;
}
sensor_module *module = new(std::nothrow) sensor_module;
retvm_if(!module || !sensor, NULL, "Failed to allocate memory");
module->sensors.push_back(sensor);
return module;
}
/**
* exec
* param[in] db handler
* param[in] query query
* return This method returns 0 (SUCCESS) or -1 (FAIL)
*/
static int _exec(sqlite3 *db, char *query)
{
int rc = 0;
char *errmsg = NULL;
retvm_if(db == NULL, -1, "DB handler is null");
rc = sqlite3_exec(db, query, NULL, 0, &errmsg);
if (rc != SQLITE_OK) {
_D("Query: [%s]", query);
_E("SQL error: %s\n", errmsg);
sqlite3_free(errmsg);
return (-1);
}
return 0;
}
static inline cts_messenger* cts_struct_dup_messenger(const cts_messenger *src)
{
cts_messenger *result = NULL;
if (src) {
result = calloc(1, sizeof(cts_messenger));
retvm_if(NULL == result, NULL, "calloc() Failed");
memcpy(result, src, sizeof(cts_messenger));
if (src->im_id)
result->im_id = strdup(src->im_id);
if (src->svc_name)
result->svc_name = strdup(src->svc_name);
if (src->svc_op)
result->svc_op = strdup(src->svc_op);
}
return result;
}
static inline cts_group* cts_struct_dup_grouprel(const cts_group *src)
{
cts_group *result = NULL;
if (src) {
result = calloc(1, sizeof(cts_group));
retvm_if(NULL == result, NULL, "calloc() Failed");
memcpy(result, src, sizeof(cts_group));
if (src->name)
result->name = strdup(src->name);
if (src->ringtone_path)
result->ringtone_path = strdup(src->ringtone_path);
if (src->img_path)
result->img_path = strdup(src->img_path);
}
return result;
}
int cts_inotify_init(void)
{
cts_inoti_fd = inotify_init();
retvm_if(-1 == cts_inoti_fd, CTS_ERR_INOTIFY_FAILED,
"inotify_init() Failed(%d)", errno);
fcntl(cts_inoti_fd, F_SETFD, FD_CLOEXEC);
fcntl(cts_inoti_fd, F_SETFL, O_NONBLOCK);
cts_inoti_handler = cts_inotify_attach_handler(cts_inoti_fd);
if (cts_inoti_handler <= 0) {
ERR("cts_inotify_attach_handler() Failed");
close(cts_inoti_fd);
cts_inoti_fd = -1;
cts_inoti_handler = 0;
return CTS_ERR_INOTIFY_FAILED;
}
return CTS_SUCCESS;
}
int _cals_alarm_add_to_db(const int event_id, cal_alarm_info_t *alarm_info)
{
CALS_FN_CALL;
int r;
sqlite3_stmt *stmt = NULL;
char query[CALS_SQL_MAX_LEN] = {0};
sprintf(query, "INSERT INTO %s ("
"event_id, "
"alarm_time, remind_tick, remind_tick_unit, alarm_tone, "
"alarm_description, alarm_type, alarm_id "
") VALUES ( "
"%d, "
"%lld, %d, %d, ?, "
"?, %d, %d )",
CALS_TABLE_ALARM,
event_id,
alarm_info->alarm_time, alarm_info->remind_tick, alarm_info->remind_tick_unit,
alarm_info->alarm_type, alarm_info->alarm_id);
DBG("query(%s)\n", query);
stmt = cals_query_prepare(query);
retvm_if(NULL == stmt, CAL_ERR_DB_FAILED, "cals_query_prepare() Failed");
if (alarm_info->alarm_tone)
cals_stmt_bind_text(stmt, 1, alarm_info->alarm_tone);
if (alarm_info->alarm_description)
cals_stmt_bind_text(stmt, 2, alarm_info->alarm_description);
r = cals_stmt_step(stmt);
sqlite3_finalize(stmt);
if (CAL_SUCCESS != r) {
ERR("cals_stmt_step() Failed(%d)", r);
return r;
}
return CAL_SUCCESS;
}
API int contacts_svc_disconnect(void)
{
CTS_FN_CALL;
retvm_if(0 == cts_conn_refcnt, CTS_ERR_ENV_INVALID,
"Contacts service was not connected");
CTS_DBG("CTS DB refcnt = %d", cts_conn_refcnt);
cts_mutex_lock(CTS_MUTEX_CONNECTION);
if (1 == cts_conn_refcnt)
{
cts_socket_final();
cts_deregister_noti();
cts_db_close();
cts_restriction_final();
cts_conn_refcnt--;
}
else
cts_conn_refcnt--;
cts_mutex_unlock(CTS_MUTEX_CONNECTION);
return CTS_SUCCESS;
}
static inline cts_company* cts_struct_dup_company(const cts_company *src)
{
cts_company *result = NULL;
if (src) {
result = calloc(1, sizeof(cts_company));
retvm_if(NULL == result, NULL, "calloc() Failed");
memcpy(result, src, sizeof(cts_company));
if (src->name)
result->name = strdup(src->name);
if (src->department)
result->department = strdup(src->department);
if (src->jot_title)
result->jot_title = strdup(src->jot_title);
if (src->role)
result->role = strdup(src->role);
if (src->assistant_name)
result->assistant_name = strdup(src->assistant_name);
}
return result;
}
int is_supported_svc(const char *svc_name)
{
int rc = 0;
int cnt = 0;
retvm_if(svc_name == NULL, 0, "Service name is null\n");
if (__doubt_sql_injection(svc_name))
return 0;
if (_init() < 0)
return 0;
cnt = __count_with_field(SYSSVC_TBL_NAME,
SYSSVC_F_SVCNAME, svc_name, 0);
if (cnt > 0)
rc = 1;
else
_D("%s is not supported.", svc_name);
__fini();
return rc;
}
static inline int _cals_update_schedule(const int index, cal_sch_full_t *current_record)
{
int ret = -1;
char query[CALS_SQL_MAX_LEN] = {0};
char dtstart_datetime[32] = {0};
char dtend_datetime[32] = {0};
sqlite3_stmt *stmt = NULL;
retv_if(NULL == current_record, CAL_ERR_ARG_NULL);
if (CAL_SYNC_STATUS_UPDATED != current_record->sync_status)
current_record->sync_status = CAL_SYNC_STATUS_UPDATED;
snprintf(query, sizeof(query), "UPDATE %s SET "
"changed_ver = %d,"
"type = %d,"
"summary = ?,"
"description = ?,"
"location = ?,"
"categories = ?,"
"exdate = ?,"
"missed = %d,"
"task_status = %d,"
"priority = %d,"
"timezone = %d, "
"file_id = %d, "
"contact_id = %d, "
"busy_status = %d, "
"sensitivity = %d, "
"uid = ?, "
"calendar_type = %d, "
"organizer_name = ?, "
"organizer_email = ?, "
"meeting_status = %d, "
"gcal_id = ?, "
"updated = ?, "
"location_type = %d, "
"location_summary = ?, "
"etag = ?, "
"calendar_id = %d, "
"sync_status = %d, "
"edit_uri = ?, "
"gevent_id = ?, "
"dst = %d,"
"original_event_id = %d,"
"latitude = %lf,"
"longitude = %lf,"
"email_id = %d,"
"availability = %d,"
"completed_time = %lld,"
"progress = %d, "
"dtstart_type = %d, "
"dtstart_utime = %lld, "
"dtstart_datetime = ?, "
"dtstart_tzid = ?, "
"dtend_type = %d, "
"dtend_utime = %lld, "
"dtend_datetime = ?, "
"dtend_tzid = ?, "
"last_mod = strftime('%%s', 'now')"
"WHERE id = %d;",
CALS_TABLE_SCHEDULE,
cals_get_next_ver(),
current_record->cal_type,
current_record->missed,
current_record->task_status,
current_record->priority,
current_record->timezone,
current_record->file_id,
current_record->contact_id,
current_record->busy_status,
current_record->sensitivity,
current_record->calendar_type,
current_record->meeting_status,
current_record->location_type,
current_record->calendar_id,
current_record->sync_status,
current_record->dst,
current_record->original_event_id,
current_record->latitude,
current_record->longitude,
current_record->email_id,
current_record->availability,
current_record->completed_time,
current_record->progress,
current_record->dtstart_type,
current_record->dtstart_utime,
current_record->dtend_type,
current_record->dtend_utime,
index);
stmt = cals_query_prepare(query);
retvm_if(NULL == stmt, CAL_ERR_DB_FAILED, "cals_query_prepare() Failed");
int count = 1;
if (current_record->summary)
cals_stmt_bind_text(stmt, count, current_record->summary);
count++;
if (current_record->description)
cals_stmt_bind_text(stmt, count, current_record->description);
count++;
if (current_record->location)
cals_stmt_bind_text(stmt, count, current_record->location);
count++;
if (current_record->categories)
cals_stmt_bind_text(stmt, count, current_record->categories);
count++;
if (current_record->exdate)
cals_stmt_bind_text(stmt, count, current_record->exdate);
count++;
if (current_record->uid)
cals_stmt_bind_text(stmt, count, current_record->uid);
count++;
if (current_record->organizer_name)
cals_stmt_bind_text(stmt, count, current_record->organizer_name);
count++;
if (current_record->organizer_email)
cals_stmt_bind_text(stmt, count, current_record->organizer_email);
count++;
if (current_record->gcal_id)
cals_stmt_bind_text(stmt, count, current_record->gcal_id);
count++;
if (current_record->updated)
cals_stmt_bind_text(stmt, count, current_record->updated);
count++;
if (current_record->location_summary)
cals_stmt_bind_text(stmt, count, current_record->location_summary);
count++;
if (current_record->etag)
cals_stmt_bind_text(stmt, count, current_record->etag);
count++;
if (current_record->edit_uri)
cals_stmt_bind_text(stmt, count, current_record->edit_uri);
count++;
if (current_record->gevent_id)
cals_stmt_bind_text(stmt, count, current_record->gevent_id);
count++;
snprintf(dtstart_datetime, sizeof(dtstart_datetime), "%04d%02d%02d",
current_record->dtstart_year,
current_record->dtstart_month,
current_record->dtstart_mday);
cals_stmt_bind_text(stmt, count, dtstart_datetime);
count++;
if (current_record->dtstart_tzid)
cals_stmt_bind_text(stmt, count, current_record->dtstart_tzid);
count++;
snprintf(dtend_datetime, sizeof(dtend_datetime), "%04d%02d%02d",
current_record->dtend_year,
current_record->dtend_month,
current_record->dtend_mday);
cals_stmt_bind_text(stmt, count, dtend_datetime);
count++;
if (current_record->dtend_tzid)
cals_stmt_bind_text(stmt, count, current_record->dtend_tzid);
count++;
ret = cals_stmt_step(stmt);
if (CAL_SUCCESS != ret) {
sqlite3_finalize(stmt);
ERR("sqlite3_step() Failed(%d)", ret);
return ret;
}
sqlite3_finalize(stmt);
return CAL_SUCCESS;
}
int cals_update_schedule(const int index, cal_sch_full_t *sch_record)
{
bool is_success = false;
cal_value * cvalue = NULL;
int ret = 0;
int rrule_id = 0;
retv_if(NULL == sch_record, CAL_ERR_ARG_NULL);
sch_record->missed = 0;
ret = _cals_update_schedule(index, sch_record);
retvm_if(CAL_SUCCESS != ret, ret, "_cals_update_schedule() Failed(%d)", ret);
if (sch_record->freq != CALS_FREQ_ONCE) {
ret = _cals_get_rrule_id(index, &rrule_id);
if (rrule_id > 0) {
ret = _cals_update_rrule(index, sch_record);
retvm_if(CAL_SUCCESS != ret, ret, "Failed in update rrule(%d)", ret);
} else {
ret = _cals_insert_rrule(index, sch_record);
if (ret < CAL_SUCCESS) {
ERR("Failed in _cals_insert_rrule(%d)\n", ret);
return ret;
}
sch_record->rrule_id = ret;
DBG("added rrule_id(%d)", ret);
ret = _cals_insert_rrule_id(index, sch_record);
if (ret != CAL_SUCCESS) {
ERR("Failed in _cals_insert_rrule_id(%d)\n", ret);
}
DBG("ended add");
}
}
_cals_delete_participant_info(index);
if (sch_record->attendee_list)
{
GList *list = g_list_first(sch_record->attendee_list);
cal_participant_info_t* participant_info = NULL;
while(list)
{
cvalue = (cal_value *)list->data;
participant_info = (cal_participant_info_t*)cvalue->user_data;
if (0 == participant_info->is_deleted) {
ret = cal_service_add_participant_info(index, participant_info);
warn_if(ret, "cal_service_add_participant_info() Failed(%d)", ret);
}
list = g_list_next(list);
}
}
/* delete registered alarm */
cals_alarm_remove(CALS_ALARM_REMOVE_BY_EVENT_ID, index);
if (sch_record->alarm_list)
{
GList *list = sch_record->alarm_list;
cal_alarm_info_t *alarm_info = NULL;
struct cals_time dtstart;
while (list)
{
cvalue = (cal_value *)list->data;
alarm_info = (cal_alarm_info_t*)cvalue->user_data;
if (alarm_info->is_deleted==0) {
if (alarm_info->remind_tick != CALS_INVALID_ID) {
dtstart.type = sch_record->dtstart_type;
dtstart.utime = sch_record->dtstart_utime;
dtstart.year = sch_record->dtstart_year;
dtstart.month = sch_record->dtstart_month;
dtstart.mday = sch_record->dtstart_mday;
ret = cals_alarm_add(index, alarm_info, &dtstart);
warn_if(CAL_SUCCESS != ret, "cals_alarm_add() Failed(%d)", ret);
}
}
list = g_list_next(list);
}
}
/* TODO: re register alarm */
/* clear instance */
ret = _cals_clear_instances(index);
if (ret) {
ERR("_cals_clear_instances failed (%d)", ret);
return ret;
}
/* insert instance */
struct cals_time st;
struct cals_time et;
st.type = sch_record->dtstart_type;
if (st.type == CALS_TIME_UTIME)
st.utime = sch_record->dtstart_utime;
else {
st.year = sch_record->dtstart_year;
st.month = sch_record->dtstart_month;
st.mday = sch_record->dtstart_mday;
}
et.type = sch_record->dtend_type;
if (et.type == CALS_TIME_UTIME)
et.utime = sch_record->dtend_utime;
else {
et.year = sch_record->dtend_year;
et.month = sch_record->dtend_month;
et.mday = sch_record->dtend_mday;
}
cals_instance_insert(index, &st, &et, sch_record);
/* set notify */
if(sch_record->cal_type == CALS_SCH_TYPE_EVENT)
is_success= cals_notify(CALS_NOTI_TYPE_EVENT);
else
is_success= cals_notify(CALS_NOTI_TYPE_TODO);
return CAL_SUCCESS;
}
static inline int _cals_insert_schedule(cal_sch_full_t *record)
{
int ret = -1;
char query[CALS_SQL_MAX_LEN] = {0};
char dtstart_datetime[32] = {0};
char dtend_datetime[32] = {0};
sqlite3_stmt *stmt = NULL;
retv_if(NULL == record, CAL_ERR_ARG_NULL);
int input_ver = cals_get_next_ver();
ret = snprintf(query, sizeof(query),
"INSERT INTO %s ("
"account_id, type, "
"created_ver, changed_ver, "
"summary, description, location, categories, exdate, "
"missed, "
"task_status, priority, timezone, file_id, "
"contact_id, busy_status, sensitivity, uid, "
"calendar_type, organizer_name, organizer_email, meeting_status, "
"gcal_id, updated, location_type, "
"location_summary, etag, calendar_id, sync_status, "
"edit_uri, gevent_id, dst, original_event_id, "
"latitude, longitude, "
"email_id, availability, "
"created_time, completed_time, progress, "
"dtstart_type, dtstart_utime, dtstart_datetime, dtstart_tzid, "
"dtend_type, dtend_utime, dtend_datetime, dtend_tzid, "
"last_mod, rrule_id "
") VALUES ( "
"%d, %d, "
"%d, %d, "
"?, ?, ?, ?, ?, "
"%d, "
"%d, %d, %d, %d, "
"%d, %d, %d, ?, "
"%d, ?, ?, %d, "
"?, ?, %d, "
"?, ?, %d, %d, "
"?, ?, %d, %d, "
"%lf, %lf, "
"%d, %d, "
"strftime('%%s', 'now'), %lld, %d, "
"%d, %lld, ?, ?, "
"%d, %lld, ?, ?, "
"strftime('%%s', 'now'), %d ) ",
CALS_TABLE_SCHEDULE,
record->account_id, record->cal_type,
input_ver, input_ver,
record->missed,
record->task_status, record->priority, record->timezone, record->file_id,
record->contact_id, record->busy_status, record->sensitivity,
record->calendar_type, record->meeting_status,
record->location_type,
record->calendar_id, record->sync_status,
record->dst, record->original_event_id,
record->latitude, record->longitude,
record->email_id, record->availability,
record->completed_time, record->progress,
record->dtstart_type, record->dtstart_utime,
record->dtend_type, record->dtend_utime,
record->rrule_id);
stmt = cals_query_prepare(query);
retvm_if(NULL == stmt, CAL_ERR_DB_FAILED, "cals_query_prepare() Failed");
int count = 1;
if (record->summary)
cals_stmt_bind_text(stmt, count, record->summary);
count++;
if (record->description)
cals_stmt_bind_text(stmt, count, record->description);
count++;
if (record->location)
cals_stmt_bind_text(stmt, count, record->location);
count++;
if (record->categories)
cals_stmt_bind_text(stmt, count, record->categories);
count++;
if (record->exdate)
cals_stmt_bind_text(stmt, count, record->exdate);
count++;
if (record->uid)
cals_stmt_bind_text(stmt, count, record->uid);
count++;
if (record->organizer_name)
cals_stmt_bind_text(stmt, count, record->organizer_name);
count++;
if (record->organizer_email)
cals_stmt_bind_text(stmt, count, record->organizer_email);
count++;
if (record->gcal_id)
cals_stmt_bind_text(stmt, count, record->gcal_id);
count++;
if (record->updated)
cals_stmt_bind_text(stmt, count, record->updated);
count++;
if (record->location_summary)
cals_stmt_bind_text(stmt, count, record->location_summary);
count++;
if (record->etag)
cals_stmt_bind_text(stmt, count, record->etag);
count++;
if (record->edit_uri)
cals_stmt_bind_text(stmt, count, record->edit_uri);
count++;
if (record->gevent_id)
cals_stmt_bind_text(stmt, count, record->gevent_id);
count++;
snprintf(dtstart_datetime, sizeof(dtstart_datetime), "%04d%02d%02dT000000",
record->dtstart_year, record->dtstart_month, record->dtstart_mday);
cals_stmt_bind_text(stmt, count, dtstart_datetime);
count++;
if (record->dtstart_tzid)
cals_stmt_bind_text(stmt, count, record->dtstart_tzid);
count++;
snprintf(dtend_datetime, sizeof(dtend_datetime), "%04d%02d%02dT235959",
record->dtend_year, record->dtend_month, record->dtend_mday);
cals_stmt_bind_text(stmt, count, dtend_datetime);
count++;
if (record->dtend_tzid)
cals_stmt_bind_text(stmt, count, record->dtend_tzid);
count++;
ret = cals_stmt_step(stmt);
if (CAL_SUCCESS != ret) {
sqlite3_finalize(stmt);
ERR("sqlite3_step() Failed(%d)", ret);
return ret;
}
sqlite3_finalize(stmt);
return cals_last_insert_id();
}
int cals_get_alarm_info(const int event_id, GList **alarm_list)
{
int ret = -1;
GList *result = NULL;
sqlite3_stmt *stmt = NULL;
cal_value * cvalue = NULL;
char query[CALS_SQL_MAX_LEN] = {0};
cal_alarm_info_t* alarm_info = NULL;
retv_if(NULL == alarm_list, CAL_ERR_ARG_NULL);
sprintf(query, "SELECT * FROM %s WHERE event_id=%d", CALS_TABLE_ALARM, event_id);
stmt = cals_query_prepare(query);
retvm_if(NULL == stmt, CAL_ERR_DB_FAILED, "cals_query_prepare() Failed");
ret = cals_stmt_step(stmt);
if (ret < CAL_SUCCESS) {
sqlite3_finalize(stmt);
ERR("cals_stmt_step() Failed(%d)", ret);
return ret;
}
while (CAL_TRUE == ret)
{
cvalue = calloc(1, sizeof(cal_value));
if (NULL == cvalue) {
sqlite3_finalize(stmt);
g_list_foreach(result, _cals_alarm_value_free, NULL);
g_list_free(result);
ERR("calloc() Failed(%d)", errno);
return CAL_ERR_OUT_OF_MEMORY;
}
cvalue->v_type = CAL_EVENT_ALARM;
cvalue->user_data = alarm_info = calloc(1, sizeof(cal_alarm_info_t));
if (NULL == alarm_info) {
sqlite3_finalize(stmt);
g_list_foreach(result, _cals_alarm_value_free, NULL);
g_list_free(result);
free(cvalue);
ERR("calloc() Failed(%d)", errno);
return CAL_ERR_OUT_OF_MEMORY;
}
alarm_info->event_id = sqlite3_column_int(stmt, 0);
alarm_info->alarm_time = sqlite3_column_int64(stmt, 1);
alarm_info->remind_tick = sqlite3_column_int(stmt, 2);
alarm_info->remind_tick_unit = sqlite3_column_int(stmt, 3);
alarm_info->alarm_tone = SAFE_STRDUP(sqlite3_column_text(stmt, 4));
alarm_info->alarm_description = SAFE_STRDUP(sqlite3_column_text(stmt, 5));
alarm_info->alarm_type = sqlite3_column_int(stmt, 6);
alarm_info->alarm_id = sqlite3_column_int(stmt, 7);
result = g_list_append(result, cvalue);
ret = cals_stmt_step(stmt);
}
sqlite3_finalize(stmt);
*alarm_list = result;
return CAL_SUCCESS;
}
int cals_alarm_remove(int type, int related_id)
{
int ret;
sqlite3_stmt *stmt = NULL;
char query[CALS_SQL_MAX_LEN] = {0};
switch (type) {
case CALS_ALARM_REMOVE_BY_EVENT_ID:
sprintf(query, "SELECT alarm_id FROM %s "
"WHERE event_id = %d AND alarm_id <> 0", CALS_TABLE_ALARM, related_id);
break;
case CALS_ALARM_REMOVE_BY_CALENDAR_ID:
sprintf(query, "SELECT alarm_id FROM %s A, %s B ON A.id = B.event_id "
"WHERE A.calendar_id = %d AND B.alarm_id <> 0",
CALS_TABLE_SCHEDULE, CALS_TABLE_ALARM, related_id);
break;
case CALS_ALARM_REMOVE_BY_ACC_ID:
sprintf(query, "SELECT alarm_id FROM %s A, %s B ON A.id = B.event_id "
"WHERE A.account_id = %d AND B.alarm_id <> 0",
CALS_TABLE_SCHEDULE, CALS_TABLE_ALARM, related_id);
break;
case CALS_ALARM_REMOVE_ALL:
sprintf(query, "SELECT alarm_id FROM %s WHERE alarm_id <> 0", CALS_TABLE_ALARM);
break;
}
stmt = cals_query_prepare(query);
retvm_if(NULL == stmt, CAL_ERR_DB_FAILED, "cals_query_prepare() Failed");
ret = cals_stmt_step(stmt);
if (ret < CAL_SUCCESS) {
sqlite3_finalize(stmt);
ERR("sqlite3_step() Failed(%d)", ret);
return CAL_ERR_DB_FAILED;
}
while (CAL_TRUE == ret) {
alarmmgr_remove_alarm(sqlite3_column_int(stmt,0));
ret = cals_stmt_step(stmt);
}
sqlite3_finalize(stmt);
// TODO: If calendar service use delete_table not delete_flag, below procedure can handle by trigger.
switch (type) {
case CALS_ALARM_REMOVE_BY_EVENT_ID:
sprintf(query, "DELETE FROM %s WHERE event_id = %d", CALS_TABLE_ALARM, related_id);
break;
case CALS_ALARM_REMOVE_BY_CALENDAR_ID:
sprintf(query, "DELETE FROM %s "
"WHERE event_id IN (SELECT id FROM %s WHERE calendar_id = %d)",
CALS_TABLE_ALARM, CALS_TABLE_SCHEDULE, related_id);
break;
case CALS_ALARM_REMOVE_BY_ACC_ID:
sprintf(query, "DELETE FROM %s "
"WHERE event_id IN (SELECT id FROM %s WHERE account_id = %d)",
CALS_TABLE_ALARM, CALS_TABLE_SCHEDULE, related_id);
break;
case CALS_ALARM_REMOVE_ALL:
sprintf(query, "DELETE FROM %s", CALS_TABLE_ALARM);
break;
}
stmt = cals_query_prepare(query);
retvm_if(NULL == stmt, CAL_ERR_DB_FAILED, "cals_query_prepare() Failed");
ret = cals_stmt_step(stmt);
if (CAL_SUCCESS != ret) {
sqlite3_finalize(stmt);
ERR("sqlite3_step(%s) Failed(%d)", query, ret);
return CAL_ERR_DB_FAILED;
}
sqlite3_finalize(stmt);
return CAL_SUCCESS;
}
static inline int _cals_update_rrule(const int index, cal_sch_full_t *record)
{
int ret;
int cnt;
char query[CALS_SQL_MAX_LEN] = {0};
char until_datetime[32] = {0};
sqlite3_stmt *stmt = NULL;
retv_if(record == NULL, CAL_ERR_ARG_NULL);
snprintf(query, sizeof(query), "UPDATE %s set "
"freq = %d, "
"range_type = %d, "
"until_type = %d, "
"until_utime = %lld, "
"until_datetime = ?, "
"count = %d, "
"interval = %d, "
"bysecond = ?, "
"byminute = ?, "
"byhour = ?, "
"byday = ?, "
"bymonthday = ?, "
"byyearday = ?, "
"byweekno = ?, "
"bymonth = ?, "
"bysetpos = ?, "
"wkst = %d "
"WHERE event_id = %d",
CALS_TABLE_RRULE,
record->freq,
record->range_type,
record->until_type,
record->until_utime,
record->count,
record->interval,
record->wkst,
index);
stmt = cals_query_prepare(query);
retvm_if(stmt == NULL, CAL_ERR_DB_FAILED, "Failed query prepare");
cnt = 1;
snprintf(until_datetime, sizeof(until_datetime), "%04d%02d%02dT235959",
record->until_year, record->until_month, record->until_mday);
cals_stmt_bind_text(stmt, cnt, until_datetime);
cnt++;
if (record->bysecond)
cals_stmt_bind_text(stmt, cnt, record->bysecond);
cnt++;
if (record->byminute)
cals_stmt_bind_text(stmt, cnt, record->byminute);
cnt++;
if (record->byhour)
cals_stmt_bind_text(stmt, cnt, record->byhour);
cnt++;
if (record->byday)
cals_stmt_bind_text(stmt, cnt, record->byday);
cnt++;
if (record->bymonthday)
cals_stmt_bind_text(stmt, cnt, record->bymonthday);
cnt++;
if (record->byyearday)
cals_stmt_bind_text(stmt, cnt, record->byyearday);
cnt++;
if (record->byweekno)
cals_stmt_bind_text(stmt, cnt, record->byweekno);
cnt++;
if (record->bymonth)
cals_stmt_bind_text(stmt, cnt, record->bymonth);
cnt++;
if (record->bysetpos)
cals_stmt_bind_text(stmt, cnt, record->bysetpos);
cnt++;
ret = cals_stmt_step(stmt);
if (CAL_SUCCESS != ret) {
sqlite3_finalize(stmt);
ERR("sqlite3_step() Failed(%d)", ret);
return ret;
}
sqlite3_finalize(stmt);
return CAL_SUCCESS;
}
int cals_insert_schedule(cal_sch_full_t *sch_record)
{
int ret = 0;
int index = 0;
cal_value *cvalue = NULL;
bool is_success = false;
struct cals_time st;
struct cals_time et;
retvm_if(NULL == sch_record, CAL_ERR_ARG_INVALID, "sch_record is NULL");
sch_record->missed = 0;
ret = cals_begin_trans();
retvm_if(ret, ret, "cals_begin_trans() is Failed(%d)", ret);
ret = _cals_insert_schedule(sch_record);
if(ret < CAL_SUCCESS) {
ERR("_cals_insert_schedule() Failed(%d)", ret);
cals_end_trans(false);
return ret;
}
index = ret;
if (sch_record->freq != CALS_FREQ_ONCE) {
ret = _cals_insert_rrule(index, sch_record);
if (ret < CAL_SUCCESS) {
ERR("Failed in _cals_insert_rrule(%d)\n", ret);
cals_end_trans(false);
return ret;
}
sch_record->rrule_id = ret;
DBG("added rrule_id(%d)", ret);
ret = _cals_insert_rrule_id(index, sch_record);
if (ret != CAL_SUCCESS) {
ERR("Failed in _cals_insert_rrule_id(%d)\n", ret);
}
DBG("ended add");
}
st.type = sch_record->dtstart_type;
if (st.type == CALS_TIME_UTIME)
st.utime = sch_record->dtstart_utime;
else {
st.year = sch_record->dtstart_year;
st.month = sch_record->dtstart_month;
st.mday = sch_record->dtstart_mday;
}
et.type = sch_record->dtend_type;
if (et.type == CALS_TIME_UTIME)
et.utime = sch_record->dtend_utime;
else {
et.year = sch_record->dtend_year;
et.month = sch_record->dtend_month;
et.mday = sch_record->dtend_mday;
}
cals_instance_insert(index, &st, &et, sch_record);
if (sch_record->attendee_list)
{
DBG("attendee exists");
GList *list = g_list_first(sch_record->attendee_list);
cal_participant_info_t *participant_info = NULL;
while(list)
{
cvalue = list->data;
if(cvalue)
{
participant_info = cvalue->user_data;
if(participant_info->is_deleted==0)
{
ret = cal_service_add_participant_info(index, participant_info);
warn_if(ret, "cal_service_add_participant_info() Failed(%d)", ret);
}
}
list = g_list_next(list);
}
} else {
DBG("No attendee exists");
}
if (sch_record->alarm_list)
{
DBG("alarm exists");
GList *list = sch_record->alarm_list;
cal_alarm_info_t *alarm_info = NULL;
while (list)
{
cvalue = list->data;
if (cvalue == NULL) {
ERR("Failed to fine value");
break;
}
alarm_info = cvalue->user_data;
if (alarm_info == NULL) {
ERR("Failed to find alarm info");
break;
}
if(alarm_info->is_deleted == 0)
{
DBG("type(%d) tick(%d) unit(%d)",
sch_record->cal_type,
alarm_info->remind_tick,
alarm_info->remind_tick_unit);
if (alarm_info->remind_tick != CALS_INVALID_ID)
{
switch (sch_record->cal_type) {
case CALS_SCH_TYPE_EVENT:
ret = cals_alarm_add(index, alarm_info, &st);
warn_if(CAL_SUCCESS != ret, "cals_alarm_add() Failed(%d)", ret);
break;
case CALS_SCH_TYPE_TODO:
if (sch_record->dtend_utime == CALS_TODO_NO_DUE_DATE) {
DBG("no due date is set");
break;
}
ret = cals_alarm_add(index, alarm_info, &et);
warn_if(CAL_SUCCESS != ret, "cals_alarm_add() Failed(%d)", ret);
break;
}
}
}
list = list->next;
}
} else {
DBG("No alarm exists");
}
cals_end_trans(true);
sch_record->index = index;
if(sch_record->cal_type == CALS_SCH_TYPE_EVENT)
is_success= cals_notify(CALS_NOTI_TYPE_EVENT);
else
is_success= cals_notify(CALS_NOTI_TYPE_TODO);
warn_if(is_success != CAL_SUCCESS, "cals_notify() Failed");
return index;
}
/**
* This function compares compares two strings which must have been normalized already.
* If search_str is included in str, this function return #CTS_SUCCESS. \n
* The behavior of this function cannot fix because of localization.
* So, The behavior can be different from each other.
*
* @param[in] haystack Base string.
* @param[in] needle searching string
* @param[out] len substring length
* @return a position of the beginning of the substring, Negative value(#cts_error) on error or difference.
* @par example
* @code
ret = contacts_svc_compare_normalized_str(str1, str2, &len);
if(CTS_SUCCESS == ret) {
snprintf(first, ret+1, "%s", item_data->display);
snprintf(middle, len+1, "%s", item_data->display + ret);
printf("%s -> %s, %s, %s", item_data->display, first, middle, item_data->display + ret + len);
} else
printf("str1 doesn't has str2");
* @endcode
*/
API int contacts_svc_normalized_strstr(const char *haystack,
const char *needle, int *len)
{
int i, j, wind, h_len, n_len;
int first_needle_len;
int equal_index;
int equal_length;
int equal_wind = 0;
bool counted = false;
retvm_if(NULL == haystack, -1, "The parameter(haystack) is NULL");
retvm_if(NULL == needle, -1, "The parameter(needle) is NULL");
CTS_DBG("haystack = %s, needle = %s", haystack, needle);
h_len = 1;
n_len = 1;
equal_index = 0;
first_needle_len = check_utf8(needle[0]);
for (i=0, j=0;i<strlen(haystack);i = wind?wind:(i+h_len)) {
if (equal_wind) {
equal_index = equal_wind;
counted = false;
}
wind = 0;
equal_length = 0;
equal_wind = 0;
for (j=0;j<strlen(needle);) {
bool equal;
h_len = check_utf8(haystack[i]);
if (h_len == 1 && haystack[i] == 0x1) { //skip seperator
counted = false;
i+=h_len;
continue;
}
n_len = check_utf8(needle[j]);
if (n_len == 1 && needle[j] == 0x1) { //skip seperator
j++;
continue;
}
if (wind == 0 && j && 0 < i) {
if (h_len == first_needle_len && compare_unicode(&haystack[i], needle, first_needle_len)
&& !is_diacritical(&haystack[i])) {
unsigned short tmp;
tmp = (haystack[i+1] << 8) | haystack[i+2];
if (!counted) {
wind = i;
equal_wind = equal_index + equal_length;
}
}
}
if ((2 == h_len && is_diacritical(&haystack[i]))
&& (2 != n_len || !is_diacritical(&needle[j]))) {
if (j == 0) {
if (counted)
equal_index++;
else {
equal_index += h_len;
counted = true;
}
}
else if (!counted) {
equal_length += h_len;
counted = true;
}
else if (counted)
equal_length++;
i+=h_len;
continue;
}
if (h_len != n_len) {
if (!counted) {
equal_index += (equal_length + h_len);
counted = true;
}
break;
}
if (3 == n_len && is_choseong(&needle[j]) && !(is_choseong(&haystack[i]))) {
if (j < (n_len+1) || !is_choseong(&needle[j-n_len-1])) { // skip 강나 search by 가나
if (!counted) {
equal_index += (equal_length + h_len);
counted = true;
}
break;
}
else {
if (j == 0) {
if (!counted) {
equal_index += h_len;
counted = true;
}
}
else if (!counted) {
equal_length += h_len;
counted = true;
}
i+=h_len;
continue;
}
}
equal = compare_unicode(&haystack[i], &needle[j], n_len);
if (equal) {
if (!counted) {
equal_length += h_len;
counted = true;
}
else if (2 == n_len && is_diacritical(&needle[j]))
equal_length ++;
j += n_len;
i+=h_len;
continue;
}
else {
if (!counted) {
equal_index += (equal_length + h_len);
counted = true;
}
else {
if (2 == n_len && is_diacritical(&needle[j]))
equal_index += (equal_length + 1);
else
equal_index += equal_length;
}
break;
}
}
if ('\0' == needle[j]) {
if ('\0' != haystack[i]) {
h_len = check_utf8(haystack[i]);
if(h_len == 2 && is_diacritical(&haystack[i]))
equal_length++;
}
*len = equal_length;
return equal_index;
}
}
CTS_DBG("NOT match");
return -1;
}
static inline int _cals_insert_rrule(int index, cal_sch_full_t *record)
{
int ret;
int cnt;
char query[CALS_SQL_MAX_LEN] = {0};
char until_datetime[32] = {0};
sqlite3_stmt *stmt = NULL;
snprintf(query, sizeof(query),
"INSERT INTO %s ( "
"event_id, freq, range_type, "
"until_type, until_utime, until_datetime, "
"count, interval, "
"bysecond, byminute, byhour, byday, "
"bymonthday, byyearday, byweekno, bymonth, "
"bysetpos, wkst "
") VALUES ( "
"%d, %d, %d, "
"%d, %lld, ?, "
"%d, %d, "
"?, ?, ?, ?, "
"?, ?, ?, ?, "
"?, %d "
") ",
CALS_TABLE_RRULE,
index, record->freq, record->range_type,
record->until_type, record->until_utime,
record->count, record->interval,
record->wkst);
stmt = cals_query_prepare(query);
retvm_if(stmt == NULL, CAL_ERR_DB_FAILED, "Failed to query prepare");
cnt = 1;
snprintf(until_datetime, sizeof(until_datetime), "%04d%02d%02dT235959",
record->until_year, record->until_month, record->until_mday);
cals_stmt_bind_text(stmt, cnt, until_datetime);
cnt++;
if (record->bysecond)
cals_stmt_bind_text(stmt, cnt, record->bysecond);
cnt++;
if (record->byminute)
cals_stmt_bind_text(stmt, cnt, record->byminute);
cnt++;
if (record->byhour)
cals_stmt_bind_text(stmt, cnt, record->byhour);
cnt++;
if (record->byday)
cals_stmt_bind_text(stmt, cnt, record->byday);
cnt++;
if (record->bymonthday)
cals_stmt_bind_text(stmt, cnt, record->bymonthday);
cnt++;
if (record->byyearday)
cals_stmt_bind_text(stmt, cnt, record->byyearday);
cnt++;
if (record->byweekno)
cals_stmt_bind_text(stmt, cnt, record->byweekno);
cnt++;
if (record->bymonth)
cals_stmt_bind_text(stmt, cnt, record->bymonth);
cnt++;
if (record->bysetpos)
cals_stmt_bind_text(stmt, cnt, record->bysetpos);
cnt++;
ret = cals_stmt_step(stmt);
if (CAL_SUCCESS != ret) {
sqlite3_finalize(stmt);
ERR("sqlite3_step() Failed(%d)", ret);
return ret;
}
sqlite3_finalize(stmt);
return cals_last_insert_id();
}
