From: Hwankyu Jhun Date: Wed, 28 Feb 2024 00:45:43 +0000 (+0900) Subject: Modify API implementations X-Git-Tag: accepted/tizen/unified/20240228.170412~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F09%2F306809%2F3;p=platform%2Fcore%2Fappfw%2Ftizen-core.git Modify API implementations - 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 --- diff --git a/include/tizen_core.h b/include/tizen_core.h index ad22929..ef6c0e6 100644 --- a/include/tizen_core.h +++ b/include/tizen_core.h @@ -82,90 +82,91 @@ int tizen_core_shutdown(void); 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 } diff --git a/include/tizen_core_channel.h b/include/tizen_core_channel.h index ad6eeb4..2a42249 100644 --- a/include/tizen_core_channel.h +++ b/include/tizen_core_channel.h @@ -27,43 +27,43 @@ typedef void *tizen_core_channel_receiver_h; 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 } diff --git a/include/tizen_core_event.h b/include/tizen_core_event.h index 3571b9d..984c9de 100644 --- a/include/tizen_core_event.h +++ b/include/tizen_core_event.h @@ -35,36 +35,38 @@ typedef bool (*tizen_core_event_handler_cb)(tizen_core_event_object_h object, 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); diff --git a/tests/tizen-core_unittests/tizen_core_channel_test.cc b/tests/tizen-core_unittests/tizen_core_channel_test.cc index 202fae9..4bb220b 100644 --- a/tests/tizen-core_unittests/tizen_core_channel_test.cc +++ b/tests/tizen-core_unittests/tizen_core_channel_test.cc @@ -247,6 +247,7 @@ TEST_F(TizenCoreChannelTest, tizen_core_channel_object_get_data_N) { 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) { @@ -255,7 +256,7 @@ TEST_F(TizenCoreChannelTest, tizen_core_channel_object_get_sender_task_name_P) { 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; diff --git a/tests/tizen-core_unittests/tizen_core_test.cc b/tests/tizen-core_unittests/tizen_core_test.cc index 8d28dc7..eafe3c9 100644 --- a/tests/tizen-core_unittests/tizen_core_test.cc +++ b/tests/tizen-core_unittests/tizen_core_test.cc @@ -143,7 +143,7 @@ class TizenCoreTest : public ::testing::Test { 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() { @@ -208,7 +208,8 @@ TEST_F(TizenCoreTest, tizen_core_task_run_P) { 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(user_data); @@ -216,7 +217,8 @@ TEST_F(TizenCoreTest, tizen_core_task_run_P) { 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_); @@ -235,15 +237,17 @@ TEST_F(TizenCoreTest, tizen_core_task_is_running_P) { 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(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_); @@ -252,9 +256,8 @@ TEST_F(TizenCoreTest, tizen_core_task_is_running_P) { } 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) { @@ -262,7 +265,9 @@ 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(user_data); @@ -270,7 +275,8 @@ TEST_F(TizenCoreTest, tizen_core_task_quit_P) { 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_); @@ -278,7 +284,8 @@ TEST_F(TizenCoreTest, tizen_core_task_quit_P) { 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(user_data); @@ -289,7 +296,7 @@ TEST_F(TizenCoreTest, tizen_core_task_quit_P) { return true; }, - this); + this, &timer_source); tizen_core_task_run(main_task_); ASSERT_EQ(touched_, true); @@ -346,7 +353,8 @@ TEST_F(TizenCoreTest, tizen_core_find_from_this_thread_P) { 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(user_data); @@ -363,7 +371,8 @@ TEST_F(TizenCoreTest, tizen_core_find_from_this_thread_P) { 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_); @@ -381,7 +390,8 @@ TEST_F(TizenCoreTest, tizen_core_add_idle_job_P) { 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(user_data); @@ -389,8 +399,8 @@ TEST_F(TizenCoreTest, tizen_core_add_idle_job_P) { 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_); @@ -398,9 +408,8 @@ TEST_F(TizenCoreTest, tizen_core_add_idle_job_P) { } 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) { @@ -408,7 +417,8 @@ 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(user_data); @@ -416,8 +426,8 @@ TEST_F(TizenCoreTest, tizen_core_add_timer_P) { 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_); @@ -425,9 +435,8 @@ TEST_F(TizenCoreTest, tizen_core_add_timer_P) { } 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) { @@ -435,7 +444,8 @@ 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(user_data); @@ -448,15 +458,16 @@ TEST_F(TizenCoreTest, tizen_core_add_channel_P) { 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(user_data); @@ -464,8 +475,8 @@ TEST_F(TizenCoreTest, tizen_core_add_channel_P) { 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_); @@ -475,9 +486,8 @@ TEST_F(TizenCoreTest, tizen_core_add_channel_P) { } 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) { @@ -485,8 +495,9 @@ 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; @@ -494,9 +505,8 @@ TEST_F(TizenCoreTest, tizen_core_add_event_P) { } 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) { @@ -518,12 +528,14 @@ 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(user_data); tizen_core_h main_core = nullptr; @@ -531,8 +543,8 @@ TEST_F(TizenCoreTest, tizen_core_emit_event_P) { 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_); @@ -629,8 +641,8 @@ TEST_F(TizenCoreTest, tizen_core_source_add_poll_N) { 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; @@ -639,44 +651,44 @@ TEST_F(TizenCoreTest, tizen_core_source_set_prepare_callback_P) { 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); } @@ -754,20 +766,21 @@ TEST_F(TizenCoreTest, tizen_core_poll_fd_set_and_get_events_N) { 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); } diff --git a/tizen_base/stub.cc b/tizen_base/stub.cc index cbeecda..89f27e8 100644 --- a/tizen_base/stub.cc +++ b/tizen_base/stub.cc @@ -118,8 +118,8 @@ API bool tizen_core_ready(void) { } 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; } @@ -128,13 +128,13 @@ API int tizen_core_task_create(const char* name, bool use_thread, 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(task.get()); + *task = static_cast(handle.get()); } catch (const std::invalid_argument& e) { _E("Exception occurs. error(%s)", e.what()); return TIZEN_CORE_ERROR_INVALID_PARAMETER; @@ -143,63 +143,63 @@ API int tizen_core_task_create(const char* name, bool use_thread, 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(h); - task->Dispose(); + auto* handle = static_cast(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(h); - task->Run(); + auto* handle = static_cast(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(h); - set_last_result(TIZEN_CORE_ERROR_NONE); - return task->IsRunning(); + auto* handle = static_cast(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(h); - task->Quit(); + auto* handle = static_cast(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(h); + *core = static_cast(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; } @@ -213,12 +213,12 @@ API int tizen_core_find(const char* name, tizen_core_h* h) { return TIZEN_CORE_ERROR_INVALID_PARAMETER; } - *h = static_cast(context->GetLoop().get()); + *core = static_cast(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; } @@ -233,167 +233,161 @@ API int tizen_core_find_from_this_thread(tizen_core_h* h) { return TIZEN_CORE_ERROR_INVALID_PARAMETER; } - *h = static_cast(context->GetLoop().get()); + *core = static_cast(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(h); - auto source = core->AddIdleJob([=]() { return callback(user_data); }); - if (source == nullptr) { + auto* task = static_cast(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(h); - auto source = core->AddTimer(interval, [=]() { return callback(user_data); }); - if (source == nullptr) { + auto* task = static_cast(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(h); - auto* receiver_h = + auto* task = static_cast(core); + auto* channel_receiver = static_cast*>(receiver); - auto source = core->AddChannel( - receiver_h->shared_from_this(), - [=](const tizen_base::tizen_core::channel::ChannelObject& obj) { + auto channel_source = task->AddChannel( + channel_receiver->shared_from_this(), + [=](const tizen_base::tizen_core::channel::ChannelObject& object) { callback( &const_cast&>( - 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(h); + auto* task = static_cast(core); auto* broker = static_cast*>(event); - auto source = core->AddEvent( + auto event_source = task->AddEvent( std::shared_ptr>( 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(h); - auto* obj = + auto* task = static_cast(core); + auto* event_object = static_cast*>(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(h); - auto* src = static_cast(source); - core->AddSource(src->shared_from_this()); + auto* task = static_cast(core); + auto* core_source = static_cast(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(source); - if (!src->IsAttached()) { + auto* core_source = static_cast(source); + if (!core_source->IsAttached()) { _E("Source(%p) is not attached", source); return TIZEN_CORE_ERROR_INVALID_CONTEXT; } - auto* core = static_cast(h); - core->RemoveSource(src->shared_from_this()); + auto* task = static_cast(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(h); - if (!core->SetCpuBoostingLevel(level)) + auto* task = static_cast(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; } @@ -401,235 +395,234 @@ API int tizen_core_source_create(tizen_core_source_h* h) { if (!tizen_core_ready()) return TIZEN_CORE_ERROR_INVALID_CONTEXT; - auto source = std::make_shared(); - if (source == nullptr) { + auto handle = std::make_shared(); + if (handle == nullptr) { _E("Out of memory"); return TIZEN_CORE_ERROR_OUT_OF_MEMORY; } - source->RefSelf(); - *h = static_cast(source.get()); + handle->RefSelf(); + *source = static_cast(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(h); - source->UnrefSelf(); + auto* handle = static_cast(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(h); - auto* pollfd = static_cast(poll_fd); - if (pollfd->GetSource() != nullptr) { + auto* handle = static_cast(source); + auto* pfd = static_cast(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(h); - auto* pollfd = static_cast(poll_fd); - if (pollfd->GetSource() == nullptr) { + auto* handle = static_cast(source); + auto* pfd = static_cast(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(h); - source->SetPrepareCb(callback, user_data); + auto* handle = static_cast(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(h); - source->SetCheckCb(callback, user_data); + auto* handle = static_cast(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(h); - source->SetDispatchCb(callback, user_data); + auto* handle = static_cast(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(h); - source->SetFinalizeCb(callback, user_data); + auto* handle = static_cast(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(h); + auto* task = static_cast(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(h); - source->SetPriority(static_cast(priority)); + auto* handle = static_cast(source); + handle->SetPriority(static_cast(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(); - if (poll_fd == nullptr) { + auto handle = std::make_shared(); + if (handle == nullptr) { _E("Out of memory"); return TIZEN_CORE_ERROR_OUT_OF_MEMORY; } - poll_fd->RefSelf(); - *h = static_cast(poll_fd.get()); + handle->RefSelf(); + *poll_fd = static_cast(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(h); - poll_fd->UnrefSelf(); + auto* handle = static_cast(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(h); - poll_fd->SetFd(fd); + auto* handle = static_cast(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(h); - *fd = poll_fd->GetFd(); + auto* handle = static_cast(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(h); - poll_fd->SetEvents(events); + auto* handle = static_cast(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(h); - *events = poll_fd->GetEvents(); + auto* handle = static_cast(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(h); - poll_fd->SetRevents(revents); + auto* handle = static_cast(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(h); - *revents = poll_fd->GetRevents(); + auto* handle = static_cast(poll_fd); + *returned_events = handle->GetRevents(); return TIZEN_CORE_ERROR_NONE; } diff --git a/tizen_base/stub_channel.cc b/tizen_base/stub_channel.cc index a4dd155..e2df6e6 100644 --- a/tizen_base/stub_channel.cc +++ b/tizen_base/stub_channel.cc @@ -57,62 +57,66 @@ API int tizen_core_channel_make_pair(tizen_core_channel_sender_h* sender, 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*>(h); - auto* object = - static_cast*>(obj); - sender->Send(*object); + auto* channel_sender = + static_cast*>(sender); + auto* channel_object = + static_cast*>( + 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*>(h); - sender->UnrefSelf(); + auto* channel_sender = + static_cast*>(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*>(h); + auto* channel_sender = + static_cast*>(sender); auto clone = std::shared_ptr>( - new tizen_base::tizen_core::channel::Sender(*sender)); + new tizen_base::tizen_core::channel::Sender(*channel_sender)); clone->RefSelf(); - *cloned_h = static_cast(clone.get()); + *cloned_sender = static_cast(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*>(h); - auto object = receiver->Receive(); - *obj = static_cast( - new tizen_base::tizen_core::channel::ChannelObject(object)); - if (*obj == nullptr) { + auto* channel_receiver = + static_cast*>(receiver); + auto channel_object = channel_receiver->Receive(); + *object = static_cast( + new tizen_base::tizen_core::channel::ChannelObject( + channel_object)); + if (*object == nullptr) { _E("Out of memory"); return TIZEN_CORE_ERROR_OUT_OF_MEMORY; } @@ -120,20 +124,21 @@ API int tizen_core_channel_receiver_receive(tizen_core_channel_receiver_h h, 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*>(h); - receiver->UnrefSelf(); + auto* channel_receiver = + static_cast*>(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; } @@ -141,91 +146,97 @@ API int tizen_core_channel_object_create(tizen_core_channel_object_h* obj) { 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(); - if (object == nullptr) { + if (channel_object == nullptr) { _E("Out of memory"); return TIZEN_CORE_ERROR_OUT_OF_MEMORY; } - *obj = static_cast(object); + *object = static_cast(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*>(obj); - delete object; + auto* channel_object = + static_cast*>( + 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*>(obj); - object->SetType(type); + auto* channel_object = + static_cast*>( + 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*>(obj); - *type = object->GetType(); + auto* channel_object = + static_cast*>( + 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*>(obj); - object->SetData(data); + auto* channel_object = + static_cast*>( + 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*>(obj); - *data = object->GetData(); + auto* channel_object = + static_cast*>( + 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*>(obj); - auto& sender = object->GetSender(); + auto* channel_object = + static_cast*>( + object); + auto& sender = channel_object->GetSender(); if (sender.empty()) { _E("Invalid context"); return TIZEN_CORE_ERROR_INVALID_CONTEXT; diff --git a/tizen_base/stub_event.cc b/tizen_base/stub_event.cc index 2d02244..1c6f400 100644 --- a/tizen_base/stub_event.cc +++ b/tizen_base/stub_event.cc @@ -80,8 +80,8 @@ class EventHandlerExt } // 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; } @@ -96,26 +96,26 @@ API int tizen_core_event_create(tizen_core_event_h* h) { return TIZEN_CORE_ERROR_OUT_OF_MEMORY; } - *h = static_cast(broker); + *event = static_cast(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*>(h); + static_cast*>(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; } @@ -127,16 +127,16 @@ API int tizen_core_event_add_handler( } auto* broker = - static_cast*>(h); + static_cast*>(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; } @@ -148,44 +148,44 @@ API int tizen_core_event_prepend_handler( } auto* broker = - static_cast*>(h); + static_cast*>(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*>(h); + static_cast*>(event); auto* handler = static_cast(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*>(h); - auto* obj = static_cast(object); - broker->Emit(obj->shared_from_this()); - obj->Unref(); + static_cast*>(event); + auto* event_object = static_cast(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; } @@ -193,67 +193,68 @@ API int tizen_core_event_object_create(tizen_core_event_object_h* h, int type, if (!tizen_core_ready()) return TIZEN_CORE_ERROR_INVALID_CONTEXT; - auto object = std::make_shared(type, data); - if (object == nullptr) { + auto event_object = std::make_shared(type, data); + if (event_object == nullptr) { _E("Out of memory"); return TIZEN_CORE_ERROR_OUT_OF_MEMORY; } - object->Ref(); - *h = static_cast(object.get()); + event_object->Ref(); + *object = static_cast(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(h); - object->SetType(-1); - object->Unref(); + auto* event_object = static_cast(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(h); - object->SetOnDestroy(callback, user_data); + auto* event_object = static_cast(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(h); - *type = object->GetType(); + auto* event_object = static_cast(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(h); - *data = object->GetData(); + auto* event_object = static_cast(object); + *data = event_object->GetData(); return TIZEN_CORE_ERROR_NONE; } API int tizen_core_event_generate_type(void) { static std::atomic type{0}; + if ((type + 1) < 0) type = 0; return type++; } \ No newline at end of file