- The return type of the functions are changed to integer.
- The return values are changed to output parameters.
- Some functions names are changed.
- The name of parameters are changed.
Change-Id: If4a5d006dbc31142247305869a4bb1f355e1337b
Signed-off-by: Hwankyu Jhun <h.jhun@samsung.com>
bool tizen_core_ready(void);
int tizen_core_task_create(const char *name, bool use_thread,
- tizen_core_task_h *h);
+ tizen_core_task_h *task);
-int tizen_core_task_destroy(tizen_core_task_h h);
+int tizen_core_task_destroy(tizen_core_task_h task);
-int tizen_core_task_run(tizen_core_task_h h);
+int tizen_core_task_run(tizen_core_task_h task);
-bool tizen_core_task_is_running(tizen_core_task_h h);
+int tizen_core_task_is_running(tizen_core_task_h task, bool *running);
-int tizen_core_task_quit(tizen_core_task_h h);
+int tizen_core_task_quit(tizen_core_task_h task);
-int tizen_core_task_get_tizen_core(tizen_core_task_h h, tizen_core_h *core);
+int tizen_core_task_get_tizen_core(tizen_core_task_h task, tizen_core_h *core);
-int tizen_core_find(const char *name, tizen_core_h *h);
+int tizen_core_find(const char *name, tizen_core_h *core);
-int tizen_core_find_from_this_thread(tizen_core_h *h);
+int tizen_core_find_from_this_thread(tizen_core_h *core);
-tizen_core_source_h tizen_core_add_idle_job(tizen_core_h h,
- tizen_core_cb callback,
- void *user_data);
+int tizen_core_add_idle_job(tizen_core_h core, tizen_core_cb callback,
+ void *user_data, tizen_core_source_h *source);
-tizen_core_source_h tizen_core_add_timer(tizen_core_h h, unsigned int interval,
- tizen_core_cb callback, void *user_data);
+int tizen_core_add_timer(tizen_core_h core, unsigned int interval,
+ tizen_core_cb callback, void *user_data,
+ tizen_core_source_h *source);
-tizen_core_source_h tizen_core_add_channel(
- tizen_core_h h, tizen_core_channel_receiver_h receiver,
- tizen_core_channel_cb callback, void *user_data);
+int tizen_core_add_channel(tizen_core_h core,
+ tizen_core_channel_receiver_h receiver,
+ tizen_core_channel_cb callback, void *user_data,
+ tizen_core_source_h *source);
-tizen_core_source_h tizen_core_add_event(tizen_core_h h,
- tizen_core_event_h event);
+int tizen_core_add_event(tizen_core_h core, tizen_core_event_h event,
+ tizen_core_source_h *source);
-int tizen_core_emit_event(tizen_core_h h, tizen_core_event_object_h object);
+int tizen_core_emit_event(tizen_core_h core, tizen_core_event_object_h object);
-int tizen_core_add_source(tizen_core_h h, tizen_core_source_h source);
+int tizen_core_add_source(tizen_core_h core, tizen_core_source_h source);
-int tizen_core_remove_source(tizen_core_h h, tizen_core_source_h source);
+int tizen_core_remove_source(tizen_core_h core, tizen_core_source_h source);
-int tizen_core_source_create(tizen_core_source_h *h);
+int tizen_core_source_create(tizen_core_source_h *source);
-int tizen_core_source_destroy(tizen_core_source_h h);
+int tizen_core_source_destroy(tizen_core_source_h source);
-int tizen_core_source_add_poll(tizen_core_source_h h,
+int tizen_core_source_add_poll(tizen_core_source_h source,
tizen_core_poll_fd_h poll_fd);
-int tizen_core_source_remove_poll(tizen_core_source_h h,
+int tizen_core_source_remove_poll(tizen_core_source_h source,
tizen_core_poll_fd_h poll_fd);
-int tizen_core_source_set_prepare_callback(
- tizen_core_source_h h, tizen_core_source_prepare_cb callback,
+int tizen_core_source_set_prepare_cb(
+ tizen_core_source_h source, tizen_core_source_prepare_cb callback,
void *user_data);
-int tizen_core_source_set_check_callback(tizen_core_source_h h,
+int tizen_core_source_set_check_cb(tizen_core_source_h source,
tizen_core_source_check_cb callback,
void *user_data);
-int tizen_core_source_set_dispatch_callback(
- tizen_core_source_h h, tizen_core_source_dispatch_cb callback,
+int tizen_core_source_set_dispatch_cb(
+ tizen_core_source_h source, tizen_core_source_dispatch_cb callback,
void *user_data);
-int tizen_core_source_set_finalize_callback(
- tizen_core_source_h h, tizen_core_source_finalize_cb callback,
+int tizen_core_source_set_finalize_cb(
+ tizen_core_source_h source, tizen_core_source_finalize_cb callback,
void *user_data);
-int tizen_core_source_set_priority(tizen_core_source_h h,
+int tizen_core_source_set_priority(tizen_core_source_h source,
tizen_core_priority_e priority);
-int tizen_core_source_get_poll_fds(tizen_core_source_h h,
- tizen_core_poll_fd_h *poll_fds,
- unsigned int *length);
+int tizen_core_poll_fd_create(tizen_core_poll_fd_h *poll_fd);
-int tizen_core_poll_fd_create(tizen_core_poll_fd_h *h);
+int tizen_core_poll_fd_destroy(tizen_core_poll_fd_h poll_fd);
-int tizen_core_poll_fd_destroy(tizen_core_poll_fd_h h);
+int tizen_core_poll_fd_set_fd(tizen_core_poll_fd_h poll_fd, int fd);
-int tizen_core_poll_fd_set_fd(tizen_core_poll_fd_h h, int fd);
+int tizen_core_poll_fd_get_fd(tizen_core_poll_fd_h poll_fd, int *fd);
-int tizen_core_poll_fd_get_fd(tizen_core_poll_fd_h h, int *fd);
+int tizen_core_poll_fd_set_events(tizen_core_poll_fd_h poll_fd,
+ uint16_t events);
-int tizen_core_poll_fd_set_events(tizen_core_poll_fd_h h, uint16_t events);
+int tizen_core_poll_fd_get_events(tizen_core_poll_fd_h poll_fd,
+ uint16_t *events);
-int tizen_core_poll_fd_get_events(tizen_core_poll_fd_h h, uint16_t *events);
+int tizen_core_poll_fd_set_returned_events(tizen_core_poll_fd_h poll_fd,
+ uint16_t returned_events);
-int tizen_core_poll_fd_set_revents(tizen_core_poll_fd_h h, uint16_t revents);
-
-int tizen_core_poll_fd_get_revents(tizen_core_poll_fd_h h, uint16_t *revents);
+int tizen_core_poll_fd_get_returned_events(tizen_core_poll_fd_h poll_fd,
+ uint16_t *returned_events);
#ifdef __cplusplus
}
typedef void *tizen_core_channel_object_h;
-typedef void (*tizen_core_channel_cb)(tizen_core_channel_object_h obj,
+typedef void (*tizen_core_channel_cb)(tizen_core_channel_object_h object,
void *user_data);
int tizen_core_channel_make_pair(tizen_core_channel_sender_h *sender,
tizen_core_channel_receiver_h *receiver);
-int tizen_core_channel_sender_send(tizen_core_channel_sender_h h,
- tizen_core_channel_object_h obj);
+int tizen_core_channel_sender_send(tizen_core_channel_sender_h sender,
+ tizen_core_channel_object_h object);
-int tizen_core_channel_sender_destroy(tizen_core_channel_sender_h h);
+int tizen_core_channel_sender_destroy(tizen_core_channel_sender_h sender);
-int tizen_core_channel_sender_clone(tizen_core_channel_sender_h h,
- tizen_core_channel_sender_h *cloned_h);
+int tizen_core_channel_sender_clone(tizen_core_channel_sender_h sender,
+ tizen_core_channel_sender_h *cloned_sender);
-int tizen_core_channel_receiver_receive(tizen_core_channel_receiver_h h,
- tizen_core_channel_object_h *obj);
+int tizen_core_channel_receiver_receive(tizen_core_channel_receiver_h receiver,
+ tizen_core_channel_object_h *object);
-int tizen_core_channel_receiver_destroy(tizen_core_channel_receiver_h h);
+int tizen_core_channel_receiver_destroy(tizen_core_channel_receiver_h receiver);
-int tizen_core_channel_object_create(tizen_core_channel_object_h *obj);
+int tizen_core_channel_object_create(tizen_core_channel_object_h *object);
-int tizen_core_channel_object_destroy(tizen_core_channel_object_h obj);
+int tizen_core_channel_object_destroy(tizen_core_channel_object_h object);
-int tizen_core_channel_object_set_type(tizen_core_channel_object_h obj,
+int tizen_core_channel_object_set_type(tizen_core_channel_object_h object,
int type);
-int tizen_core_channel_object_get_type(tizen_core_channel_object_h obj,
+int tizen_core_channel_object_get_type(tizen_core_channel_object_h object,
int *type);
-int tizen_core_channel_object_set_data(tizen_core_channel_object_h obj,
+int tizen_core_channel_object_set_data(tizen_core_channel_object_h object,
void *data);
-int tizen_core_channel_object_get_data(tizen_core_channel_object_h obj,
+int tizen_core_channel_object_get_data(tizen_core_channel_object_h object,
void **data);
int tizen_core_channel_object_get_sender_task_name(
- tizen_core_channel_object_h obj, const char **task_name);
+ tizen_core_channel_object_h object, const char **task_name);
#ifdef __cplusplus
}
typedef void (*tizen_core_event_object_on_destroy_cb)(void *data,
void *user_data);
-int tizen_core_event_create(tizen_core_event_h *h);
+int tizen_core_event_create(tizen_core_event_h *event);
-int tizen_core_event_destroy(tizen_core_event_h h);
+int tizen_core_event_destroy(tizen_core_event_h event);
int tizen_core_event_add_handler(
- tizen_core_event_h h, tizen_core_event_handler_cb callback,
+ tizen_core_event_h event, tizen_core_event_handler_cb callback,
void *user_data, tizen_core_event_handler_h *event_handler);
int tizen_core_event_prepend_handler(
- tizen_core_event_h h, tizen_core_event_handler_cb callback,
+ tizen_core_event_h event, tizen_core_event_handler_cb callback,
void *user_data, tizen_core_event_handler_h *event_handler);
int tizen_core_event_remove_handler(
- tizen_core_event_h h, tizen_core_event_handler_h event_handler);
+ tizen_core_event_h event, tizen_core_event_handler_h event_handler);
-int tizen_core_event_emit(tizen_core_event_h h,
+int tizen_core_event_emit(tizen_core_event_h event,
tizen_core_event_object_h object);
-int tizen_core_event_object_create(tizen_core_event_object_h *h, int type,
+int tizen_core_event_object_create(tizen_core_event_object_h *object, int type,
void *data);
-int tizen_core_event_object_destroy(tizen_core_event_object_h h);
+int tizen_core_event_object_destroy(tizen_core_event_object_h object);
int tizen_core_event_object_set_on_destroy(
- tizen_core_event_object_h h, tizen_core_event_object_on_destroy_cb callback,
- void *user_data);
+ tizen_core_event_object_h object,
+ tizen_core_event_object_on_destroy_cb callback, void *user_data);
-int tizen_core_event_object_get_type(tizen_core_event_object_h h, int *type);
+int tizen_core_event_object_get_type(tizen_core_event_object_h object,
+ int *type);
-int tizen_core_event_object_get_data(tizen_core_event_object_h h, void **data);
+int tizen_core_event_object_get_data(tizen_core_event_object_h object,
+ void **data);
int tizen_core_event_generate_type(void);
TEST_F(TizenCoreChannelTest, tizen_core_channel_object_get_sender_task_name_P) {
tizen_core_h core = nullptr;
tizen_core_task_get_tizen_core(sender_task_, &core);
+ tizen_core_source_h source = nullptr;
tizen_core_add_idle_job(
core,
[](void* user_data) {
tizen_core_task_quit(test->sender_task_);
return false;
},
- this);
+ this, &source);
tizen_core_task_run(sender_task_);
tizen_core_channel_object_h object = nullptr;
tizen_core_poll_fd_create(&poll_fd_);
tizen_core_poll_fd_set_fd(poll_fd_, 0);
tizen_core_poll_fd_set_events(poll_fd_, TIZEN_CORE_POLL_EVENT_IN);
- tizen_core_poll_fd_set_revents(poll_fd_, TIZEN_CORE_POLL_EVENT_IN);
+ tizen_core_poll_fd_set_returned_events(poll_fd_, TIZEN_CORE_POLL_EVENT_IN);
}
void TCorePollFdTearDown() {
ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(core, nullptr);
- auto source = tizen_core_add_idle_job(
+ tizen_core_source_h source = nullptr;
+ ret = tizen_core_add_idle_job(
core,
[](void* user_data) {
auto test = static_cast<TizenCoreTest*>(user_data);
tizen_core_task_quit(test->main_task_);
return false;
},
- this);
+ this, &source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(source, nullptr);
ret = tizen_core_task_run(main_task_);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(core, nullptr);
- auto source = tizen_core_add_idle_job(
+ tizen_core_source_h source = nullptr;
+ ret = tizen_core_add_idle_job(
core,
[](void* user_data) {
auto test = static_cast<TizenCoreTest*>(user_data);
- test->touched_ = tizen_core_task_is_running(test->main_task_);
+ tizen_core_task_is_running(test->main_task_, &test->touched_);
tizen_core_task_quit(test->main_task_);
return false;
},
- this);
+ this, &source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(source, nullptr);
ret = tizen_core_task_run(main_task_);
}
TEST_F(TizenCoreTest, tizen_core_task_is_running_N) {
- bool ret = tizen_core_task_is_running(nullptr);
- ASSERT_EQ(ret, false);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_INVALID_PARAMETER);
+ int ret = tizen_core_task_is_running(nullptr, nullptr);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
TEST_F(TizenCoreTest, tizen_core_task_quit_P) {
int ret = tizen_core_task_get_tizen_core(task_, &core);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(core, nullptr);
- auto source = tizen_core_add_idle_job(
+
+ tizen_core_source_h source = nullptr;
+ ret = tizen_core_add_idle_job(
core,
[](void* user_data) {
auto* test = static_cast<TizenCoreTest*>(user_data);
test->touched_ = true;
return false;
},
- this);
+ this, &source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(source, nullptr);
ret = tizen_core_task_run(task_);
core = nullptr;
tizen_core_task_get_tizen_core(main_task_, &core);
- source = tizen_core_add_timer(
+ tizen_core_source_h timer_source = nullptr;
+ ret = tizen_core_add_timer(
core, 100,
[](void* user_data) {
auto* test = static_cast<TizenCoreTest*>(user_data);
return true;
},
- this);
+ this, &timer_source);
tizen_core_task_run(main_task_);
ASSERT_EQ(touched_, true);
core = nullptr;
tizen_core_task_get_tizen_core(task_, &core);
- auto source = tizen_core_add_idle_job(
+ tizen_core_source_h source = nullptr;
+ ret = tizen_core_add_idle_job(
core,
[](void* user_data) -> bool {
auto* test = static_cast<TizenCoreTest*>(user_data);
tizen_core_task_quit(test->main_task_);
return false;
},
- this);
+ this, &source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(source, nullptr);
tizen_core_task_run(task_);
tizen_core_task_get_tizen_core(main_task_, &core);
ASSERT_NE(core, nullptr);
- auto source = tizen_core_add_idle_job(
+ tizen_core_source_h source = nullptr;
+ int ret = tizen_core_add_idle_job(
core,
[](void* user_data) {
auto* test = static_cast<TizenCoreTest*>(user_data);
tizen_core_task_quit(test->main_task_);
return false;
},
- this);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_NONE);
+ this, &source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(source, nullptr);
tizen_core_task_run(main_task_);
}
TEST_F(TizenCoreTest, tizen_core_add_idle_job_N) {
- auto source = tizen_core_add_idle_job(nullptr, nullptr, nullptr);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(source, nullptr);
+ int ret = tizen_core_add_idle_job(nullptr, nullptr, nullptr, nullptr);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
TEST_F(TizenCoreTest, tizen_core_add_timer_P) {
tizen_core_task_get_tizen_core(main_task_, &core);
ASSERT_NE(core, nullptr);
- auto source = tizen_core_add_timer(
+ tizen_core_source_h source = nullptr;
+ int ret = tizen_core_add_timer(
core, 100,
[](void* user_data) {
auto* test = static_cast<TizenCoreTest*>(user_data);
tizen_core_task_quit(test->main_task_);
return false;
},
- this);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_NONE);
+ this, &source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(source, nullptr);
tizen_core_task_run(main_task_);
}
TEST_F(TizenCoreTest, tizen_core_add_timer_N) {
- auto source = tizen_core_add_timer(nullptr, 0, nullptr, nullptr);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(source, nullptr);
+ int ret = tizen_core_add_timer(nullptr, 0, nullptr, nullptr, nullptr);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
TEST_F(TizenCoreTest, tizen_core_add_channel_P) {
tizen_core_task_get_tizen_core(main_task_, &main_core);
ASSERT_NE(main_core, nullptr);
- auto source = tizen_core_add_channel(
+ tizen_core_source_h source = nullptr;
+ int ret = tizen_core_add_channel(
main_core, receiver_,
[](tizen_core_channel_object_h object, void* user_data) {
auto* test = static_cast<TizenCoreTest*>(user_data);
test->touched_ = true;
tizen_core_task_quit(test->main_task_);
- }, this);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_NONE);
+ }, this, &source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(source, nullptr);
tizen_core_h core = nullptr;
tizen_core_task_get_tizen_core(task_, &core);
ASSERT_NE(core, nullptr);
- auto idle_source = tizen_core_add_idle_job(
+ tizen_core_source_h idle_source = nullptr;
+ ret = tizen_core_add_idle_job(
core,
[](void* user_data) {
auto* test = static_cast<TizenCoreTest*>(user_data);
tizen_core_task_quit(test->task_);
return false;
},
- this);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_NONE);
+ this, &idle_source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(idle_source, nullptr);
tizen_core_task_run(task_);
}
TEST_F(TizenCoreTest, tizen_core_add_channel_N) {
- auto source = tizen_core_add_channel(nullptr, nullptr, nullptr, nullptr);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(source, nullptr);
+ int ret = tizen_core_add_channel(nullptr, nullptr, nullptr, nullptr, nullptr);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
TEST_F(TizenCoreTest, tizen_core_add_event_P) {
tizen_core_task_get_tizen_core(main_task_, &core);
ASSERT_NE(core, nullptr);
- auto source = tizen_core_add_event(core, event_);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_NONE);
+ tizen_core_source_h source = nullptr;
+ int ret = tizen_core_add_event(core, event_, &source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(source, nullptr);
event_ = nullptr;
}
TEST_F(TizenCoreTest, tizen_core_add_event_N) {
- auto source = tizen_core_add_event(nullptr, nullptr);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_INVALID_PARAMETER);
- ASSERT_EQ(source, nullptr);
+ int ret = tizen_core_add_event(nullptr, nullptr, nullptr);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
TEST_F(TizenCoreTest, tizen_core_emit_event_P) {
tizen_core_task_get_tizen_core(main_task_, &core);
ASSERT_NE(core, nullptr);
- auto source = tizen_core_add_event(core, event_);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_NONE);
+ tizen_core_source_h source = nullptr;
+ ret = tizen_core_add_event(core, event_, &source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(source, nullptr);
event_ = nullptr;
- auto timer_source = tizen_core_add_timer(
+ tizen_core_source_h timer_source = nullptr;
+ ret = tizen_core_add_timer(
core, 100, [](void* user_data) {
auto* test = static_cast<TizenCoreTest*>(user_data);
tizen_core_h main_core = nullptr;
tizen_core_emit_event(main_core, test->event_object_);
test->event_object_ = nullptr;
return false;
- }, this);
- ASSERT_EQ(get_last_result(), TIZEN_CORE_ERROR_NONE);
+ }, this, &timer_source);
+ ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_NE(timer_source, nullptr);
tizen_core_task_run(main_task_);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
-TEST_F(TizenCoreTest, tizen_core_source_set_prepare_callback_P) {
- int ret = tizen_core_source_set_prepare_callback(
+TEST_F(TizenCoreTest, tizen_core_source_set_prepare_cb_P) {
+ int ret = tizen_core_source_set_prepare_cb(
source_,
[](tizen_core_source_h source, int* timeout, void* user_data) {
return true;
ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
}
-TEST_F(TizenCoreTest, tizen_core_source_set_prepare_callback_N) {
- int ret = tizen_core_source_set_prepare_callback(nullptr, nullptr, nullptr);
+TEST_F(TizenCoreTest, tizen_core_source_set_prepare_cb_N) {
+ int ret = tizen_core_source_set_prepare_cb(nullptr, nullptr, nullptr);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
-TEST_F(TizenCoreTest, tizen_core_source_set_check_callback_P) {
- int ret = tizen_core_source_set_check_callback(
+TEST_F(TizenCoreTest, tizen_core_source_set_check_cb_P) {
+ int ret = tizen_core_source_set_check_cb(
source_,
[](tizen_core_source_h source, void* user_data) { return true; }, this);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
}
-TEST_F(TizenCoreTest, tizen_core_source_set_check_callback_N) {
- int ret = tizen_core_source_set_check_callback(nullptr, nullptr, nullptr);
+TEST_F(TizenCoreTest, tizen_core_source_set_check_cb_N) {
+ int ret = tizen_core_source_set_check_cb(nullptr, nullptr, nullptr);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
-TEST_F(TizenCoreTest, tizen_core_source_set_dispatch_callback_P) {
- int ret = tizen_core_source_set_dispatch_callback(
+TEST_F(TizenCoreTest, tizen_core_source_set_dispatch_cb_P) {
+ int ret = tizen_core_source_set_dispatch_cb(
source_,
[](tizen_core_source_h source, void* user_data) { return true; }, this);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
}
-TEST_F(TizenCoreTest, tizen_core_source_set_dispatch_callback_N) {
- int ret = tizen_core_source_set_dispatch_callback(nullptr, nullptr, nullptr);
+TEST_F(TizenCoreTest, tizen_core_source_set_dispatch_cb_N) {
+ int ret = tizen_core_source_set_dispatch_cb(nullptr, nullptr, nullptr);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
-TEST_F(TizenCoreTest, tizen_core_source_set_finalize_callback_P) {
- int ret = tizen_core_source_set_finalize_callback(
+TEST_F(TizenCoreTest, tizen_core_source_set_finalize_cb_P) {
+ int ret = tizen_core_source_set_finalize_cb(
source_,
[](tizen_core_source_h source, void* user_data) {}, this);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
}
-TEST_F(TizenCoreTest, tizen_core_source_set_finalize_callback_N) {
- int ret = tizen_core_source_set_finalize_callback(nullptr, nullptr, nullptr);
+TEST_F(TizenCoreTest, tizen_core_source_set_finalize_cb_N) {
+ int ret = tizen_core_source_set_finalize_cb(nullptr, nullptr, nullptr);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
-TEST_F(TizenCoreTest, tizen_core_poll_fd_set_and_get_revents_P) {
- int ret = tizen_core_poll_fd_set_revents(poll_fd_, TIZEN_CORE_POLL_EVENT_IN);
+TEST_F(TizenCoreTest, tizen_core_poll_fd_set_and_get_returned_events_P) {
+ int ret = tizen_core_poll_fd_set_returned_events(poll_fd_,
+ TIZEN_CORE_POLL_EVENT_IN);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
uint16_t revents = 0;
- ret = tizen_core_poll_fd_get_revents(poll_fd_, &revents);
+ ret = tizen_core_poll_fd_get_returned_events(poll_fd_, &revents);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_NONE);
ASSERT_EQ(revents, TIZEN_CORE_POLL_EVENT_IN);
}
-TEST_F(TizenCoreTest, tizen_core_poll_fd_set_and_get_revents_N) {
- int ret = tizen_core_poll_fd_set_revents(nullptr, 0);
+TEST_F(TizenCoreTest, tizen_core_poll_fd_set_and_get_returned_events_N) {
+ int ret = tizen_core_poll_fd_set_returned_events(nullptr, 0);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
- ret = tizen_core_poll_fd_get_revents(nullptr, nullptr);
+ ret = tizen_core_poll_fd_get_returned_events(nullptr, nullptr);
ASSERT_EQ(ret, TIZEN_CORE_ERROR_INVALID_PARAMETER);
}
}
API int tizen_core_task_create(const char* name, bool use_thread,
- tizen_core_task_h* h) {
- if (name == nullptr || h == nullptr) {
+ tizen_core_task_h* task) {
+ if (name == nullptr || task == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
return TIZEN_CORE_ERROR_INVALID_CONTEXT;
try {
- auto task = tizen_base::tizen_core::Task::Create(name, use_thread);
- if (task == nullptr) {
+ auto handle = tizen_base::tizen_core::Task::Create(name, use_thread);
+ if (handle == nullptr) {
_E("Out of memory");
return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
- *h = static_cast<tizen_core_task_h>(task.get());
+ *task = static_cast<tizen_core_task_h>(handle.get());
} catch (const std::invalid_argument& e) {
_E("Exception occurs. error(%s)", e.what());
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_task_destroy(tizen_core_task_h h) {
- if (h == nullptr) {
+API int tizen_core_task_destroy(tizen_core_task_h task) {
+ if (task == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* task = static_cast<tizen_base::tizen_core::Task*>(h);
- task->Dispose();
+ auto* handle = static_cast<tizen_base::tizen_core::Task*>(task);
+ handle->Dispose();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_task_run(tizen_core_task_h h) {
- if (h == nullptr) {
+API int tizen_core_task_run(tizen_core_task_h task) {
+ if (task == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* task = static_cast<tizen_base::tizen_core::Task*>(h);
- task->Run();
+ auto* handle = static_cast<tizen_base::tizen_core::Task*>(task);
+ handle->Run();
return TIZEN_CORE_ERROR_NONE;
}
-API bool tizen_core_task_is_running(tizen_core_task_h h) {
- if (h == nullptr) {
- set_last_result(TIZEN_CORE_ERROR_INVALID_PARAMETER);
- return false;
+API int tizen_core_task_is_running(tizen_core_task_h task, bool* running) {
+ if (task == nullptr || running == nullptr) {
+ _E("Invalid parameter");
+ return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* task = static_cast<tizen_base::tizen_core::Task*>(h);
- set_last_result(TIZEN_CORE_ERROR_NONE);
- return task->IsRunning();
+ auto* handle = static_cast<tizen_base::tizen_core::Task*>(task);
+ *running = handle->IsRunning();
+ return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_task_quit(tizen_core_task_h h) {
- if (h == nullptr) {
+API int tizen_core_task_quit(tizen_core_task_h task) {
+ if (task == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* task = static_cast<tizen_base::tizen_core::Task*>(h);
- task->Quit();
+ auto* handle = static_cast<tizen_base::tizen_core::Task*>(task);
+ handle->Quit();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_task_get_tizen_core(tizen_core_task_h h,
+API int tizen_core_task_get_tizen_core(tizen_core_task_h task,
tizen_core_h* core) {
- if (h == nullptr || core == nullptr) {
+ if (task == nullptr || core == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- *core = static_cast<tizen_core_h>(h);
+ *core = static_cast<tizen_core_h>(task);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_find(const char* name, tizen_core_h* h) {
- if (name == nullptr || h == nullptr) {
+API int tizen_core_find(const char* name, tizen_core_h* core) {
+ if (name == nullptr || core == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- *h = static_cast<tizen_core_h>(context->GetLoop().get());
+ *core = static_cast<tizen_core_h>(context->GetLoop().get());
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_find_from_this_thread(tizen_core_h* h) {
- if (h == nullptr) {
+API int tizen_core_find_from_this_thread(tizen_core_h* core) {
+ if (core == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- *h = static_cast<tizen_core_h>(context->GetLoop().get());
+ *core = static_cast<tizen_core_h>(context->GetLoop().get());
return TIZEN_CORE_ERROR_NONE;
}
-API tizen_core_source_h tizen_core_add_idle_job(tizen_core_h h,
- tizen_core_cb callback,
- void* user_data) {
- if (h == nullptr || callback == nullptr) {
+API int tizen_core_add_idle_job(tizen_core_h core, tizen_core_cb callback,
+ void* user_data, tizen_core_source_h* source) {
+ if (core == nullptr || callback == nullptr || source == nullptr) {
_E("Invalid parameter");
- set_last_result(TIZEN_CORE_ERROR_INVALID_PARAMETER);
- return nullptr;
+ return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* core = static_cast<tizen_base::tizen_core::Task*>(h);
- auto source = core->AddIdleJob([=]() { return callback(user_data); });
- if (source == nullptr) {
+ auto* task = static_cast<tizen_base::tizen_core::Task*>(core);
+ auto idle_source = task->AddIdleJob([=]() { return callback(user_data); });
+ if (idle_source == nullptr) {
_E("Failed to add idle job");
- set_last_result(TIZEN_CORE_ERROR_OUT_OF_MEMORY);
- return nullptr;
+ return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
- set_last_result(TIZEN_CORE_ERROR_NONE);
- return source.get();
+ *source = idle_source.get();
+ return TIZEN_CORE_ERROR_NONE;
}
-API tizen_core_source_h tizen_core_add_timer(tizen_core_h h,
- unsigned int interval,
- tizen_core_cb callback,
- void* user_data) {
- if (h == nullptr || callback == nullptr) {
+API int tizen_core_add_timer(tizen_core_h core, unsigned int interval,
+ tizen_core_cb callback, void* user_data,
+ tizen_core_source_h* source) {
+ if (core == nullptr || callback == nullptr || source == nullptr) {
_E("Invalid parameter");
- set_last_result(TIZEN_CORE_ERROR_INVALID_PARAMETER);
- return nullptr;
+ return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* core = static_cast<tizen_base::tizen_core::Task*>(h);
- auto source = core->AddTimer(interval, [=]() { return callback(user_data); });
- if (source == nullptr) {
+ auto* task = static_cast<tizen_base::tizen_core::Task*>(core);
+ auto timer_source =
+ task->AddTimer(interval, [=]() { return callback(user_data); });
+ if (timer_source == nullptr) {
_E("Failed to add timer");
- set_last_result(TIZEN_CORE_ERROR_OUT_OF_MEMORY);
- return nullptr;
+ return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
- set_last_result(TIZEN_CORE_ERROR_NONE);
- return source.get();
+ *source = timer_source.get();
+ return TIZEN_CORE_ERROR_NONE;
}
-API tizen_core_source_h
-tizen_core_add_channel(tizen_core_h h, tizen_core_channel_receiver_h receiver,
- tizen_core_channel_cb callback, void* user_data) {
- if (h == nullptr || receiver == nullptr || callback == nullptr) {
+API int tizen_core_add_channel(tizen_core_h core,
+ tizen_core_channel_receiver_h receiver,
+ tizen_core_channel_cb callback, void* user_data,
+ tizen_core_source_h* source) {
+ if (core == nullptr || receiver == nullptr || callback == nullptr ||
+ source == nullptr) {
_E("Invalid parameter");
- set_last_result(TIZEN_CORE_ERROR_INVALID_PARAMETER);
- return nullptr;
+ return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* core = static_cast<tizen_base::tizen_core::Task*>(h);
- auto* receiver_h =
+ auto* task = static_cast<tizen_base::tizen_core::Task*>(core);
+ auto* channel_receiver =
static_cast<tizen_base::tizen_core::channel::Receiver<void*>*>(receiver);
- auto source = core->AddChannel<void*>(
- receiver_h->shared_from_this(),
- [=](const tizen_base::tizen_core::channel::ChannelObject<void*>& obj) {
+ auto channel_source = task->AddChannel<void*>(
+ channel_receiver->shared_from_this(),
+ [=](const tizen_base::tizen_core::channel::ChannelObject<void*>& object) {
callback(
&const_cast<tizen_base::tizen_core::channel::ChannelObject<void*>&>(
- obj),
+ object),
user_data);
});
- if (source == nullptr) {
+ if (channel_source == nullptr) {
_E("Failed to add channel");
- set_last_result(TIZEN_CORE_ERROR_OUT_OF_MEMORY);
- return nullptr;
+ return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
- set_last_result(TIZEN_CORE_ERROR_NONE);
- return source.get();
+ *source = channel_source.get();
+ return TIZEN_CORE_ERROR_NONE;
}
-API tizen_core_source_h tizen_core_add_event(tizen_core_h h,
- tizen_core_event_h event) {
- if (h == nullptr || event == nullptr) {
+API int tizen_core_add_event(tizen_core_h core, tizen_core_event_h event,
+ tizen_core_source_h* source) {
+ if (core == nullptr || event == nullptr || source == nullptr) {
_E("Invalid parameter");
- set_last_result(TIZEN_CORE_ERROR_INVALID_PARAMETER);
- return nullptr;
+ return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* core = static_cast<tizen_base::tizen_core::Task*>(h);
+ auto* task = static_cast<tizen_base::tizen_core::Task*>(core);
auto* broker =
static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(event);
- auto source = core->AddEvent(
+ auto event_source = task->AddEvent(
std::shared_ptr<tizen_base::tizen_core::event::EventBroker<void*>>(
broker));
- if (source == nullptr) {
+ if (event_source == nullptr) {
_E("Failed to add event");
- set_last_result(TIZEN_CORE_ERROR_OUT_OF_MEMORY);
- return nullptr;
+ return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
- set_last_result(TIZEN_CORE_ERROR_NONE);
- return source.get();
+ *source = event_source.get();
+ return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_emit_event(tizen_core_h h,
+API int tizen_core_emit_event(tizen_core_h core,
tizen_core_event_object_h object) {
- if (h == nullptr || object == nullptr) {
+ if (core == nullptr || object == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* core = static_cast<tizen_base::tizen_core::Task*>(h);
- auto* obj =
+ auto* task = static_cast<tizen_base::tizen_core::Task*>(core);
+ auto* event_object =
static_cast<tizen_base::tizen_core::event::EventObject<void*>*>(object);
- core->EmitEvent(obj->shared_from_this());
- obj->Unref();
+ task->EmitEvent(event_object->shared_from_this());
+ event_object->Unref();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_add_source(tizen_core_h h, tizen_core_source_h source) {
- if (h == nullptr || source == nullptr) {
+API int tizen_core_add_source(tizen_core_h core, tizen_core_source_h source) {
+ if (core == nullptr || source == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* core = static_cast<tizen_base::tizen_core::Task*>(h);
- auto* src = static_cast<tizen_base::tizen_core::Source*>(source);
- core->AddSource(src->shared_from_this());
+ auto* task = static_cast<tizen_base::tizen_core::Task*>(core);
+ auto* core_source = static_cast<tizen_base::tizen_core::Source*>(source);
+ task->AddSource(core_source->shared_from_this());
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_remove_source(tizen_core_h h, tizen_core_source_h source) {
- if (h == nullptr || source == nullptr) {
+API int tizen_core_remove_source(tizen_core_h core,
+ tizen_core_source_h source) {
+ if (core == nullptr || source == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* src = static_cast<tizen_base::tizen_core::Source*>(source);
- if (!src->IsAttached()) {
+ auto* core_source = static_cast<tizen_base::tizen_core::Source*>(source);
+ if (!core_source->IsAttached()) {
_E("Source(%p) is not attached", source);
return TIZEN_CORE_ERROR_INVALID_CONTEXT;
}
- auto* core = static_cast<tizen_base::tizen_core::Task*>(h);
- core->RemoveSource(src->shared_from_this());
+ auto* task = static_cast<tizen_base::tizen_core::Task*>(core);
+ task->RemoveSource(core_source->shared_from_this());
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_set_cpu_boosting_level(tizen_core_h h,
- tizen_core_cpu_boosting_level_e level) {
- if (h == nullptr) {
+API int tizen_core_set_cpu_boosting_level(
+ tizen_core_h core, tizen_core_cpu_boosting_level_e level) {
+ if (core == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* core = static_cast<tizen_base::tizen_core::Task*>(h);
- if (!core->SetCpuBoostingLevel(level))
+ auto* task = static_cast<tizen_base::tizen_core::Task*>(core);
+ if (!task->SetCpuBoostingLevel(level))
return TIZEN_CORE_ERROR_INVALID_CONTEXT;
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_source_create(tizen_core_source_h* h) {
- if (h == nullptr) {
+API int tizen_core_source_create(tizen_core_source_h* source) {
+ if (source == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
if (!tizen_core_ready())
return TIZEN_CORE_ERROR_INVALID_CONTEXT;
- auto source = std::make_shared<SourceExt>();
- if (source == nullptr) {
+ auto handle = std::make_shared<SourceExt>();
+ if (handle == nullptr) {
_E("Out of memory");
return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
- source->RefSelf();
- *h = static_cast<tizen_core_source_h>(source.get());
+ handle->RefSelf();
+ *source = static_cast<tizen_core_source_h>(handle.get());
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_source_destroy(tizen_core_source_h h) {
- if (h == nullptr) {
+API int tizen_core_source_destroy(tizen_core_source_h source) {
+ if (source == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* source = static_cast<tizen_base::tizen_core::Source*>(h);
- source->UnrefSelf();
+ auto* handle = static_cast<tizen_base::tizen_core::Source*>(source);
+ handle->UnrefSelf();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_source_add_poll(tizen_core_source_h h,
+API int tizen_core_source_add_poll(tizen_core_source_h source,
tizen_core_poll_fd_h poll_fd) {
- if (h == nullptr || poll_fd == nullptr) {
+ if (source == nullptr || poll_fd == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* source = static_cast<SourceExt*>(h);
- auto* pollfd = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
- if (pollfd->GetSource() != nullptr) {
+ auto* handle = static_cast<SourceExt*>(source);
+ auto* pfd = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
+ if (pfd->GetSource() != nullptr) {
_E("Invalid context");
return TIZEN_CORE_ERROR_INVALID_CONTEXT;
}
- source->AddPoll(pollfd->shared_from_this());
+ handle->AddPoll(pfd->shared_from_this());
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_source_remove_poll(tizen_core_source_h h,
+API int tizen_core_source_remove_poll(tizen_core_source_h source,
tizen_core_poll_fd_h poll_fd) {
- if (h == nullptr || poll_fd == nullptr) {
+ if (source == nullptr || poll_fd == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* source = static_cast<SourceExt*>(h);
- auto* pollfd = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
- if (pollfd->GetSource() == nullptr) {
+ auto* handle = static_cast<SourceExt*>(source);
+ auto* pfd = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
+ if (pfd->GetSource() == nullptr) {
_E("Invalid context");
return TIZEN_CORE_ERROR_INVALID_CONTEXT;
}
- auto pollfd_ptr = pollfd->shared_from_this();
- source->RemovePoll(pollfd_ptr);
+ handle->RemovePoll(pfd->shared_from_this());
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_source_set_prepare_callback(
- tizen_core_source_h h, tizen_core_source_prepare_cb callback,
- void* user_data) {
- if (h == nullptr) {
+API int tizen_core_source_set_prepare_cb(tizen_core_source_h source,
+ tizen_core_source_prepare_cb callback,
+ void* user_data) {
+ if (source == nullptr || callback == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* source = static_cast<SourceExt*>(h);
- source->SetPrepareCb(callback, user_data);
+ auto* handle = static_cast<SourceExt*>(source);
+ handle->SetPrepareCb(callback, user_data);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_source_set_check_callback(
- tizen_core_source_h h, tizen_core_source_check_cb callback,
- void* user_data) {
- if (h == nullptr) {
+API int tizen_core_source_set_check_cb(tizen_core_source_h source,
+ tizen_core_source_check_cb callback,
+ void* user_data) {
+ if (source == nullptr || callback == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* source = static_cast<SourceExt*>(h);
- source->SetCheckCb(callback, user_data);
+ auto* handle = static_cast<SourceExt*>(source);
+ handle->SetCheckCb(callback, user_data);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_source_set_dispatch_callback(
- tizen_core_source_h h, tizen_core_source_dispatch_cb callback,
+API int tizen_core_source_set_dispatch_cb(
+ tizen_core_source_h source, tizen_core_source_dispatch_cb callback,
void* user_data) {
- if (h == nullptr) {
+ if (source == nullptr || callback == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* source = static_cast<SourceExt*>(h);
- source->SetDispatchCb(callback, user_data);
+ auto* handle = static_cast<SourceExt*>(source);
+ handle->SetDispatchCb(callback, user_data);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_source_set_finalize_callback(
- tizen_core_source_h h, tizen_core_source_finalize_cb callback,
+API int tizen_core_source_set_finalize_cb(
+ tizen_core_source_h source, tizen_core_source_finalize_cb callback,
void* user_data) {
- if (h == nullptr) {
+ if (source == nullptr || callback == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* source = static_cast<SourceExt*>(h);
- source->SetFinalizeCb(callback, user_data);
+ auto* handle = static_cast<SourceExt*>(source);
+ handle->SetFinalizeCb(callback, user_data);
return TIZEN_CORE_ERROR_NONE;
}
-API void* tizen_core_get_glib_context(tizen_core_h h) {
- if (h == nullptr) {
+API void* tizen_core_get_glib_context(tizen_core_h core) {
+ if (core == nullptr) {
_E("Invalid parameter");
set_last_result(TIZEN_CORE_ERROR_INVALID_PARAMETER);
return nullptr;
}
- auto* core = static_cast<tizen_base::tizen_core::Task*>(h);
+ auto* task = static_cast<tizen_base::tizen_core::Task*>(core);
set_last_result(TIZEN_CORE_ERROR_NONE);
- return core->GetContext()->GetHandle();
+ return task->GetContext()->GetHandle();
}
-API int tizen_core_source_set_priority(tizen_core_source_h h,
+API int tizen_core_source_set_priority(tizen_core_source_h source,
tizen_core_priority_e priority) {
- if (h == nullptr) {
+ if (source == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* source = static_cast<SourceExt*>(h);
- source->SetPriority(static_cast<int>(priority));
+ auto* handle = static_cast<SourceExt*>(source);
+ handle->SetPriority(static_cast<int>(priority));
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_poll_fd_create(tizen_core_poll_fd_h* h) {
- if (h == nullptr) {
+API int tizen_core_poll_fd_create(tizen_core_poll_fd_h* poll_fd) {
+ if (poll_fd == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto poll_fd = std::make_shared<tizen_base::tizen_core::PollFd>();
- if (poll_fd == nullptr) {
+ auto handle = std::make_shared<tizen_base::tizen_core::PollFd>();
+ if (handle == nullptr) {
_E("Out of memory");
return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
- poll_fd->RefSelf();
- *h = static_cast<tizen_core_poll_fd_h>(poll_fd.get());
+ handle->RefSelf();
+ *poll_fd = static_cast<tizen_core_poll_fd_h>(handle.get());
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_poll_fd_destroy(tizen_core_poll_fd_h h) {
- if (h == nullptr) {
+API int tizen_core_poll_fd_destroy(tizen_core_poll_fd_h poll_fd) {
+ if (poll_fd == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* poll_fd = static_cast<tizen_base::tizen_core::PollFd*>(h);
- poll_fd->UnrefSelf();
+ auto* handle = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
+ handle->UnrefSelf();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_poll_fd_set_fd(tizen_core_poll_fd_h h, int fd) {
- if (h == nullptr || fd < 0) {
+API int tizen_core_poll_fd_set_fd(tizen_core_poll_fd_h poll_fd, int fd) {
+ if (poll_fd == nullptr || fd < 0) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* poll_fd = static_cast<tizen_base::tizen_core::PollFd*>(h);
- poll_fd->SetFd(fd);
+ auto* handle = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
+ handle->SetFd(fd);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_poll_fd_get_fd(tizen_core_poll_fd_h h, int* fd) {
- if (h == nullptr || fd == nullptr) {
+API int tizen_core_poll_fd_get_fd(tizen_core_poll_fd_h poll_fd, int* fd) {
+ if (poll_fd == nullptr || fd == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* poll_fd = static_cast<tizen_base::tizen_core::PollFd*>(h);
- *fd = poll_fd->GetFd();
+ auto* handle = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
+ *fd = handle->GetFd();
return TIZEN_CORE_ERROR_NONE;
}
-
-API int tizen_core_poll_fd_set_events(tizen_core_poll_fd_h h, uint16_t events) {
- if (h == nullptr || events == 0) {
+API int tizen_core_poll_fd_set_events(tizen_core_poll_fd_h poll_fd,
+ uint16_t events) {
+ if (poll_fd == nullptr || events == 0) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* poll_fd = static_cast<tizen_base::tizen_core::PollFd*>(h);
- poll_fd->SetEvents(events);
+ auto* handle = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
+ handle->SetEvents(events);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_poll_fd_get_events(tizen_core_poll_fd_h h,
+API int tizen_core_poll_fd_get_events(tizen_core_poll_fd_h poll_fd,
uint16_t* events) {
- if (h == nullptr || events == nullptr) {
+ if (poll_fd == nullptr || events == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* poll_fd = static_cast<tizen_base::tizen_core::PollFd*>(h);
- *events = poll_fd->GetEvents();
+ auto* handle = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
+ *events = handle->GetEvents();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_poll_fd_set_revents(tizen_core_poll_fd_h h,
- uint16_t revents) {
- if (h == nullptr) {
+API int tizen_core_poll_fd_set_returned_events(tizen_core_poll_fd_h poll_fd,
+ uint16_t returned_events) {
+ if (poll_fd == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* poll_fd = static_cast<tizen_base::tizen_core::PollFd*>(h);
- poll_fd->SetRevents(revents);
+ auto* handle = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
+ handle->SetRevents(returned_events);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_poll_fd_get_revents(tizen_core_poll_fd_h h,
- uint16_t* revents) {
- if (h == nullptr || revents == nullptr) {
+API int tizen_core_poll_fd_get_returned_events(tizen_core_poll_fd_h poll_fd,
+ uint16_t* returned_events) {
+ if (poll_fd == nullptr || returned_events == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* poll_fd = static_cast<tizen_base::tizen_core::PollFd*>(h);
- *revents = poll_fd->GetRevents();
+ auto* handle = static_cast<tizen_base::tizen_core::PollFd*>(poll_fd);
+ *returned_events = handle->GetRevents();
return TIZEN_CORE_ERROR_NONE;
}
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_sender_send(tizen_core_channel_sender_h h,
- tizen_core_channel_object_h obj) {
- if (h == nullptr || obj == nullptr) {
+API int tizen_core_channel_sender_send(tizen_core_channel_sender_h sender,
+ tizen_core_channel_object_h object) {
+ if (sender == nullptr || object == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* sender =
- static_cast<tizen_base::tizen_core::channel::Sender<void*>*>(h);
- auto* object =
- static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(obj);
- sender->Send(*object);
+ auto* channel_sender =
+ static_cast<tizen_base::tizen_core::channel::Sender<void*>*>(sender);
+ auto* channel_object =
+ static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(
+ object);
+ channel_sender->Send(*channel_object);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_sender_destroy(tizen_core_channel_sender_h h) {
- if (h == nullptr) {
+API int tizen_core_channel_sender_destroy(tizen_core_channel_sender_h sender) {
+ if (sender == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* sender =
- static_cast<tizen_base::tizen_core::channel::Sender<void*>*>(h);
- sender->UnrefSelf();
+ auto* channel_sender =
+ static_cast<tizen_base::tizen_core::channel::Sender<void*>*>(sender);
+ channel_sender->UnrefSelf();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_sender_clone(tizen_core_channel_sender_h h,
- tizen_core_channel_sender_h* cloned_h) {
- if (h == nullptr || cloned_h == nullptr) {
+API int tizen_core_channel_sender_clone(
+ tizen_core_channel_sender_h sender,
+ tizen_core_channel_sender_h* cloned_sender) {
+ if (sender == nullptr || cloned_sender == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* sender =
- static_cast<tizen_base::tizen_core::channel::Sender<void*>*>(h);
+ auto* channel_sender =
+ static_cast<tizen_base::tizen_core::channel::Sender<void*>*>(sender);
auto clone = std::shared_ptr<tizen_base::tizen_core::channel::Sender<void*>>(
- new tizen_base::tizen_core::channel::Sender<void*>(*sender));
+ new tizen_base::tizen_core::channel::Sender<void*>(*channel_sender));
clone->RefSelf();
- *cloned_h = static_cast<tizen_core_channel_sender_h>(clone.get());
+ *cloned_sender = static_cast<tizen_core_channel_sender_h>(clone.get());
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_receiver_receive(tizen_core_channel_receiver_h h,
- tizen_core_channel_object_h* obj) {
- if (h == nullptr || obj == nullptr) {
+API int tizen_core_channel_receiver_receive(
+ tizen_core_channel_receiver_h receiver,
+ tizen_core_channel_object_h* object) {
+ if (receiver == nullptr || object == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* receiver =
- static_cast<tizen_base::tizen_core::channel::Receiver<void*>*>(h);
- auto object = receiver->Receive();
- *obj = static_cast<tizen_core_channel_object_h>(
- new tizen_base::tizen_core::channel::ChannelObject<void*>(object));
- if (*obj == nullptr) {
+ auto* channel_receiver =
+ static_cast<tizen_base::tizen_core::channel::Receiver<void*>*>(receiver);
+ auto channel_object = channel_receiver->Receive();
+ *object = static_cast<tizen_core_channel_object_h>(
+ new tizen_base::tizen_core::channel::ChannelObject<void*>(
+ channel_object));
+ if (*object == nullptr) {
_E("Out of memory");
return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_receiver_destroy(tizen_core_channel_receiver_h h) {
- if (h == nullptr) {
+API int tizen_core_channel_receiver_destroy(
+ tizen_core_channel_receiver_h receiver) {
+ if (receiver == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* receiver =
- static_cast<tizen_base::tizen_core::channel::Receiver<void*>*>(h);
- receiver->UnrefSelf();
+ auto* channel_receiver =
+ static_cast<tizen_base::tizen_core::channel::Receiver<void*>*>(receiver);
+ channel_receiver->UnrefSelf();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_object_create(tizen_core_channel_object_h* obj) {
- if (obj == nullptr) {
+API int tizen_core_channel_object_create(tizen_core_channel_object_h* object) {
+ if (object == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
if (!tizen_core_ready())
return TIZEN_CORE_ERROR_INVALID_CONTEXT;
- auto* object = new (std::nothrow)
+ auto* channel_object = new (std::nothrow)
tizen_base::tizen_core::channel::ChannelObject<void*>();
- if (object == nullptr) {
+ if (channel_object == nullptr) {
_E("Out of memory");
return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
- *obj = static_cast<tizen_core_channel_object_h>(object);
+ *object = static_cast<tizen_core_channel_object_h>(channel_object);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_object_destroy(tizen_core_channel_object_h obj) {
- if (obj == nullptr) {
+API int tizen_core_channel_object_destroy(tizen_core_channel_object_h object) {
+ if (object == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* object =
- static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(obj);
- delete object;
+ auto* channel_object =
+ static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(
+ object);
+ delete channel_object;
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_object_set_type(tizen_core_channel_object_h obj,
+API int tizen_core_channel_object_set_type(tizen_core_channel_object_h object,
int type) {
- if (obj == nullptr) {
+ if (object == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* object =
- static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(obj);
- object->SetType(type);
+ auto* channel_object =
+ static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(
+ object);
+ channel_object->SetType(type);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_object_get_type(tizen_core_channel_object_h obj,
+API int tizen_core_channel_object_get_type(tizen_core_channel_object_h object,
int* type) {
- if (obj == nullptr || type == nullptr) {
+ if (object == nullptr || type == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* object =
- static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(obj);
- *type = object->GetType();
+ auto* channel_object =
+ static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(
+ object);
+ *type = channel_object->GetType();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_object_set_data(tizen_core_channel_object_h obj,
+API int tizen_core_channel_object_set_data(tizen_core_channel_object_h object,
void* data) {
- if (obj == nullptr) {
+ if (object == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* object =
- static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(obj);
- object->SetData(data);
+ auto* channel_object =
+ static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(
+ object);
+ channel_object->SetData(data);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_channel_object_get_data(tizen_core_channel_object_h obj,
+API int tizen_core_channel_object_get_data(tizen_core_channel_object_h object,
void** data) {
- if (obj == nullptr || data == nullptr) {
+ if (object == nullptr || data == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* object =
- static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(obj);
- *data = object->GetData();
+ auto* channel_object =
+ static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(
+ object);
+ *data = channel_object->GetData();
return TIZEN_CORE_ERROR_NONE;
}
API int tizen_core_channel_object_get_sender_task_name(
- tizen_core_channel_object_h obj, const char** task_name) {
- if (obj == nullptr || task_name == nullptr) {
+ tizen_core_channel_object_h object, const char** task_name) {
+ if (object == nullptr || task_name == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* object =
- static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(obj);
- auto& sender = object->GetSender();
+ auto* channel_object =
+ static_cast<tizen_base::tizen_core::channel::ChannelObject<void*>*>(
+ object);
+ auto& sender = channel_object->GetSender();
if (sender.empty()) {
_E("Invalid context");
return TIZEN_CORE_ERROR_INVALID_CONTEXT;
} // namespace
-API int tizen_core_event_create(tizen_core_event_h* h) {
- if (h == nullptr) {
+API int tizen_core_event_create(tizen_core_event_h* event) {
+ if (event == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
- *h = static_cast<tizen_core_event_h>(broker);
+ *event = static_cast<tizen_core_event_h>(broker);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_event_destroy(tizen_core_event_h h) {
- if (h == nullptr) {
+API int tizen_core_event_destroy(tizen_core_event_h event) {
+ if (event == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
auto* broker =
- static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(h);
+ static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(event);
delete broker;
return TIZEN_CORE_ERROR_NONE;
}
API int tizen_core_event_add_handler(
- tizen_core_event_h h, tizen_core_event_handler_cb callback,
+ tizen_core_event_h event, tizen_core_event_handler_cb callback,
void* user_data, tizen_core_event_handler_h* event_handler) {
- if (h == nullptr || callback == nullptr || event_handler == nullptr) {
+ if (event == nullptr || callback == nullptr || event_handler == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
}
auto* broker =
- static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(h);
+ static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(event);
broker->AddHandler(handler);
*event_handler = handler.get();
return TIZEN_CORE_ERROR_NONE;
}
API int tizen_core_event_prepend_handler(
- tizen_core_event_h h, tizen_core_event_handler_cb callback, void* user_data,
- tizen_core_event_handler_h* event_handler) {
- if (h == nullptr || callback == nullptr || event_handler == nullptr) {
+ tizen_core_event_h event, tizen_core_event_handler_cb callback,
+ void* user_data, tizen_core_event_handler_h* event_handler) {
+ if (event == nullptr || callback == nullptr || event_handler == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
}
auto* broker =
- static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(h);
+ static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(event);
broker->PrependHandler(handler);
*event_handler = handler.get();
return TIZEN_CORE_ERROR_NONE;
}
API int tizen_core_event_remove_handler(
- tizen_core_event_h h, tizen_core_event_handler_h event_handler) {
- if (h == nullptr || event_handler == nullptr) {
+ tizen_core_event_h event, tizen_core_event_handler_h event_handler) {
+ if (event == nullptr || event_handler == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
auto* broker =
- static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(h);
+ static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(event);
auto* handler = static_cast<EventHandlerExt*>(event_handler);
broker->RemoveHandler(handler->shared_from_this());
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_event_emit(tizen_core_event_h h,
+API int tizen_core_event_emit(tizen_core_event_h event,
tizen_core_event_object_h object) {
- if (h == nullptr || object == nullptr) {
+ if (event == nullptr || object == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
auto* broker =
- static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(h);
- auto* obj = static_cast<EventObjectExt*>(object);
- broker->Emit(obj->shared_from_this());
- obj->Unref();
+ static_cast<tizen_base::tizen_core::event::EventBroker<void*>*>(event);
+ auto* event_object = static_cast<EventObjectExt*>(object);
+ broker->Emit(event_object->shared_from_this());
+ event_object->Unref();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_event_object_create(tizen_core_event_object_h* h, int type,
- void* data) {
- if (h == nullptr) {
+API int tizen_core_event_object_create(tizen_core_event_object_h* object,
+ int type, void* data) {
+ if (object == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
if (!tizen_core_ready())
return TIZEN_CORE_ERROR_INVALID_CONTEXT;
- auto object = std::make_shared<EventObjectExt>(type, data);
- if (object == nullptr) {
+ auto event_object = std::make_shared<EventObjectExt>(type, data);
+ if (event_object == nullptr) {
_E("Out of memory");
return TIZEN_CORE_ERROR_OUT_OF_MEMORY;
}
- object->Ref();
- *h = static_cast<tizen_core_event_object_h>(object.get());
+ event_object->Ref();
+ *object = static_cast<tizen_core_event_object_h>(event_object.get());
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_event_object_destroy(tizen_core_event_object_h h) {
- if (h == nullptr) {
+API int tizen_core_event_object_destroy(tizen_core_event_object_h object) {
+ if (object == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* object = static_cast<EventObjectExt*>(h);
- object->SetType(-1);
- object->Unref();
+ auto* event_object = static_cast<EventObjectExt*>(object);
+ event_object->SetType(-1);
+ event_object->Unref();
return TIZEN_CORE_ERROR_NONE;
}
API int tizen_core_event_object_set_on_destroy(
- tizen_core_event_object_h h, tizen_core_event_object_on_destroy_cb callback,
- void* user_data) {
- if (h == nullptr || callback == nullptr) {
+ tizen_core_event_object_h object,
+ tizen_core_event_object_on_destroy_cb callback, void* user_data) {
+ if (object == nullptr || callback == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* object = static_cast<EventObjectExt*>(h);
- object->SetOnDestroy(callback, user_data);
+ auto* event_object = static_cast<EventObjectExt*>(object);
+ event_object->SetOnDestroy(callback, user_data);
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_event_object_get_type(tizen_core_event_object_h h,
+API int tizen_core_event_object_get_type(tizen_core_event_object_h object,
int* type) {
- if (h == nullptr || type == nullptr) {
+ if (object == nullptr || type == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* object = static_cast<EventObjectExt*>(h);
- *type = object->GetType();
+ auto* event_object = static_cast<EventObjectExt*>(object);
+ *type = event_object->GetType();
return TIZEN_CORE_ERROR_NONE;
}
-API int tizen_core_event_object_get_data(tizen_core_event_object_h h,
+API int tizen_core_event_object_get_data(tizen_core_event_object_h object,
void** data) {
- if (h == nullptr || data == nullptr) {
+ if (object == nullptr || data == nullptr) {
_E("Invalid parameter");
return TIZEN_CORE_ERROR_INVALID_PARAMETER;
}
- auto* object = static_cast<EventObjectExt*>(h);
- *data = object->GetData();
+ auto* event_object = static_cast<EventObjectExt*>(object);
+ *data = event_object->GetData();
return TIZEN_CORE_ERROR_NONE;
}
API int tizen_core_event_generate_type(void) {
static std::atomic<int> type{0};
+ if ((type + 1) < 0) type = 0;
return type++;
}
\ No newline at end of file
projects / platform / core / appfw / tizen-core.git / commitdiff