From: Inkyun Kil Date: Mon, 27 Apr 2020 08:25:54 +0000 (+0900) Subject: Improves coverage for watch_holder X-Git-Tag: submit/tizen_5.5/20200508.080019^2~2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=8de3fbfa8fd38ed924d61d905cedb0d2fa23d7cc;p=platform%2Fcore%2Fappfw%2Fwidget-viewer.git Improves coverage for watch_holder Change-Id: I3d8d0f40710e8ce31af173ef55958cfea80519a3 Signed-off-by: Inkyun Kil --- diff --git a/unittest/mock/evas_mock.h b/unittest/mock/evas_mock.h index 603998f6..9086375f 100644 --- a/unittest/mock/evas_mock.h +++ b/unittest/mock/evas_mock.h @@ -29,7 +29,11 @@ extern "C" { DECLARE_FAKE_VALUE_FUNC(Evas_Object *, elm_win_add, Evas_Object *, const char *, Elm_Win_Type); +DECLARE_FAKE_VALUE_FUNC(int, elm_win_aux_hint_add, Evas_Object *, const char *, + const char *); + DECLARE_FAKE_VALUE_FUNC(Evas_Object *, elm_layout_add, Evas_Object *); +DECLARE_FAKE_VALUE_FUNC(Evas *, evas_object_evas_get, const Eo *); DECLARE_FAKE_VALUE_FUNC(Eina_Bool, elm_layout_file_set, Eo *, const char *, const char *); @@ -46,6 +50,11 @@ DECLARE_FAKE_VOID_FUNC(evas_object_event_callback_add, Evas_Object *, DECLARE_FAKE_VOID_FUNC(elm_object_signal_callback_add, Evas_Object *, const char *, const char *, Edje_Signal_Cb, void *); +DECLARE_FAKE_VOID_FUNC(evas_object_smart_callback_add, Evas_Object *, + const char *, Evas_Smart_Cb, const void *); +DECLARE_FAKE_VALUE_FUNC(void *, evas_object_smart_callback_del, Evas_Object *, + const char *, Evas_Smart_Cb); + DECLARE_FAKE_VOID_FUNC(elm_object_part_content_set, Evas_Object *, const char *, Evas_Object *); @@ -63,6 +72,15 @@ DECLARE_FAKE_VALUE_FUNC(int, tbm_surface_map, tbm_surface_h, int, tbm_surface_info_s *); DECLARE_FAKE_VALUE_FUNC(int, tbm_surface_unmap, tbm_surface_h); +DECLARE_FAKE_VALUE_FUNC(Ecore_Evas*, ecore_evas_ecore_evas_get, const Evas*); +DECLARE_FAKE_VALUE_FUNC(Ecore_Wl2_Window*, ecore_evas_wayland2_window_get, + const Ecore_Evas*); + +DECLARE_FAKE_VALUE_FUNC(const char*, elm_win_aux_msg_key_get, + Evas_Object*, Elm_Win_Aux_Message*); +DECLARE_FAKE_VALUE_FUNC(const char*, elm_win_aux_msg_val_get, + Evas_Object*, Elm_Win_Aux_Message*); + #ifdef __cplusplus } #endif diff --git a/unittest/mock/mock.cc b/unittest/mock/mock.cc index 86937897..10b321ba 100644 --- a/unittest/mock/mock.cc +++ b/unittest/mock/mock.cc @@ -36,6 +36,9 @@ DEFINE_FAKE_VALUE_FUNC(int, cynara_creds_gdbus_get_user, GDBusConnection*, /* evas */ DEFINE_FAKE_VALUE_FUNC(Evas_Object *, elm_win_add, Evas_Object *, const char *, Elm_Win_Type); +DEFINE_FAKE_VALUE_FUNC(int, elm_win_aux_hint_add, Evas_Object *, const char *, + const char *); +DEFINE_FAKE_VALUE_FUNC(Evas *, evas_object_evas_get, const Eo *); DEFINE_FAKE_VALUE_FUNC(Evas_Object *, elm_layout_add, Evas_Object *); DEFINE_FAKE_VALUE_FUNC(Eina_Bool, elm_layout_file_set, Eo *, const char *, const char *); @@ -47,6 +50,10 @@ DEFINE_FAKE_VOID_FUNC(evas_object_event_callback_add, Evas_Object *, Evas_Callback_Type, Evas_Object_Event_Cb, const void *); DEFINE_FAKE_VOID_FUNC(elm_object_signal_callback_add, Evas_Object *, const char *, const char *, Edje_Signal_Cb, void *); +DEFINE_FAKE_VOID_FUNC(evas_object_smart_callback_add, Evas_Object *, + const char *, Evas_Smart_Cb, const void *); +DEFINE_FAKE_VALUE_FUNC(void *, evas_object_smart_callback_del, Evas_Object *, + const char *, Evas_Smart_Cb); DEFINE_FAKE_VOID_FUNC(elm_object_part_content_set, Evas_Object *, const char *, Evas_Object *); DEFINE_FAKE_VALUE_FUNC(Evas_Object *, elm_object_part_content_get, @@ -60,6 +67,13 @@ DEFINE_FAKE_VALUE_FUNC(Evas_Native_Surface *, DEFINE_FAKE_VALUE_FUNC(int, tbm_surface_map, tbm_surface_h, int, tbm_surface_info_s *); DEFINE_FAKE_VALUE_FUNC(int, tbm_surface_unmap, tbm_surface_h); +DEFINE_FAKE_VALUE_FUNC(Ecore_Evas*, ecore_evas_ecore_evas_get, const Evas*); +DEFINE_FAKE_VALUE_FUNC(Ecore_Wl2_Window*, ecore_evas_wayland2_window_get, + const Ecore_Evas*); +DEFINE_FAKE_VALUE_FUNC(const char*, elm_win_aux_msg_key_get, + Evas_Object*, Elm_Win_Aux_Message*); +DEFINE_FAKE_VALUE_FUNC(const char*, elm_win_aux_msg_val_get, + Evas_Object*, Elm_Win_Aux_Message*); /* aul */ DEFINE_FAKE_VALUE_FUNC(int, aul_app_get_appid_bypid, int, char *, int); diff --git a/unittest/src/test_watch.cc b/unittest/src/test_watch.cc index 4da4ed5c..771514f5 100644 --- a/unittest/src/test_watch.cc +++ b/unittest/src/test_watch.cc @@ -21,10 +21,48 @@ #include #include +#include + using namespace std; using namespace tizen_base; using namespace watch_holder; +gchar __not_null; + +Ecore_Evas* __ecore_evas_ecore_evas_get_fake(const Evas* obj) { + return nullptr; +} + +Ecore_Wl2_Window* __ecore_evas_wayland2_window_get_fake(const Ecore_Evas* obj) { + return nullptr; +} + +int __elm_win_aux_hint_add_fake(Evas_Object* obj, const char* h, const char* v) { + return 0; +} + +void __evas_object_smart_callback_add_fake(Evas_Object* obj, const char* event, + Evas_Smart_Cb func, const void* data) { + func((void*)data, nullptr, nullptr); +} + +void* __evas_object_smart_callback_del_fake(Evas_Object* obj, const char* event, + Evas_Smart_Cb func) { + return nullptr; +} + +Evas* __evas_object_evas_get_fake(const Eo *obj) { + return nullptr; +} + +const char* __elm_win_aux_msg_key_get_fake(Evas_Object* obj, Elm_Win_Aux_Message *msg) { + return "tz_remote_surface_mng"; +} + +const char* __elm_win_aux_msg_val_get_fake(Evas_Object* obj, Elm_Win_Aux_Message *msg) { + return "prebind"; +} + class WatchMirrorStub : public WatchMirror { public: WatchMirrorStub(Evas_Object* win) @@ -51,6 +89,28 @@ class WatchStub : public Watch{ WatchStub(int rid, std::string id, string appid, Evas_Object* win, tizen_base::Bundle extra, WatchMirrorStub* listener) : Watch(rid, id, appid, win, extra, listener, true) { } + + void InvokeEvasAdded() { + screen_connector::EvasObject eo(reinterpret_cast(&__not_null), + false); + OnEvasAdded("TestAppId", "TestInstId", 99, eo); + } + + void InvokeEvasRemoved() { + screen_connector::EvasObject eo(reinterpret_cast(&__not_null), + false); + OnEvasRemoved("TestAppId", "TestInstId", 99, eo); + } + + void InvokeEvasChanged() { + screen_connector::EvasObject eo(reinterpret_cast(&__not_null), + false); + OnEvasChanged("TestAppId", "TestInstId", 99, eo); + } + + void InvokeSetFaulted(bool faulted) { + SetFaulted(faulted); + } }; class WatchTest : public ::testing::Test { @@ -77,6 +137,7 @@ TEST_F(WatchTest, CreateInstance) { TEST_F(WatchTest, CreateInstance2) { Evas_Object* mirwin = elm_win_add(NULL, "Watch Mirror", ELM_WIN_BASIC); WatchMirrorStub* mirrorstub = new WatchMirrorStub(mirwin); + EXPECT_NE(mirrorstub, nullptr); Evas_Object* win = elm_win_add(NULL, "Watch", ELM_WIN_BASIC); WatchStub* stub = new WatchStub(0, string("id"), string("test"), win, mirrorstub); EXPECT_NE(stub, nullptr); @@ -90,6 +151,7 @@ TEST_F(WatchTest, CreateInstance3) { b.Add("__APP_AMBIENT_SENDER__", "test"); Evas_Object* mirwin = elm_win_add(NULL, "Watch Mirror", ELM_WIN_BASIC); WatchMirrorStub* mirrorstub = new WatchMirrorStub(mirwin); + EXPECT_NE(mirrorstub, nullptr); Evas_Object* win = elm_win_add(NULL, "Watch", ELM_WIN_BASIC); WatchStub* stub = new WatchStub(string("test"), win, b, mirrorstub); EXPECT_NE(stub, nullptr); @@ -103,6 +165,7 @@ TEST_F(WatchTest, CreateInstance4) { b.Add("__APP_AMBIENT_SENDER__", "test"); Evas_Object* mirwin = elm_win_add(NULL, "Watch Mirror", ELM_WIN_BASIC); WatchMirrorStub* mirrorstub = new WatchMirrorStub(mirwin); + EXPECT_NE(mirrorstub, nullptr); Evas_Object* win = elm_win_add(NULL, "Watch", ELM_WIN_BASIC); WatchStub* stub = new WatchStub(0, string("id"), string("test"), win, b,mirrorstub); EXPECT_NE(stub, nullptr); @@ -110,30 +173,90 @@ TEST_F(WatchTest, CreateInstance4) { delete mirrorstub; } -TEST_F(WatchTest, Terminate) { - WatchTest::stub->Terminate(); +TEST_F(WatchTest, Terminate_N) { + int ret; + ret = WatchTest::stub->Terminate(); + EXPECT_NE(ret, 0); } TEST_F(WatchTest, GetPid) { - WatchTest::stub->GetPid(); + int ret; + ret = WatchTest::stub->GetPid(); + EXPECT_EQ(ret, 0); } TEST_F(WatchTest, IsBound) { - WatchTest::stub->IsBound(); + bool is_bound; + is_bound = WatchTest::stub->IsBound(); + EXPECT_EQ(is_bound, false); } TEST_F(WatchTest, GetAppId) { - WatchTest::stub->GetAppId(); + string appid; + appid = WatchTest::stub->GetAppId(); + EXPECT_EQ(appid, "test"); } -TEST_F(WatchTest, GetCurrentImage) { - WatchTest::stub->GetCurrentImage(); +TEST_F(WatchTest, GetCurrentImage_N) { + Evas_Object* cur; + cur = WatchTest::stub->GetCurrentImage(); + EXPECT_EQ(cur, nullptr); } TEST_F(WatchTest, GetExtra) { - WatchTest::stub->GetExtra(); + Bundle b; + b = WatchTest::stub->GetExtra(); + EXPECT_EQ(b.GetCount(), 0); } TEST_F(WatchTest, IsFaulted) { - WatchTest::stub->IsFaulted(); + bool is_faulted; + is_faulted = WatchTest::stub->IsFaulted(); + EXPECT_EQ(is_faulted, false); +} + +TEST_F(WatchTest, SetFaulted) { + bool is_faulted; + WatchTest::stub->InvokeSetFaulted(true); + is_faulted = WatchTest::stub->IsFaulted(); + EXPECT_EQ(is_faulted, true); +} + +TEST_F(WatchTest, BlockUpdate) { + EXPECT_NE(WatchTest::stub, nullptr); + WatchTest::stub->BlockUpdate(true); +} + +TEST_F(WatchTest, NotifyChangedEvent_N) { + EXPECT_EQ(-1, WatchTest::stub->NotifyChangedEvent()); +} + +TEST_F(WatchTest, Bind) { + ecore_evas_ecore_evas_get_fake.custom_fake = __ecore_evas_ecore_evas_get_fake; + ecore_evas_wayland2_window_get_fake.custom_fake = __ecore_evas_wayland2_window_get_fake; + elm_win_aux_hint_add_fake.custom_fake = __elm_win_aux_hint_add_fake; + evas_object_smart_callback_add_fake.custom_fake = __evas_object_smart_callback_add_fake; + evas_object_smart_callback_del_fake.custom_fake = __evas_object_smart_callback_del_fake; + evas_object_evas_get_fake.custom_fake = __evas_object_evas_get_fake; + elm_win_aux_msg_key_get_fake.custom_fake = __elm_win_aux_msg_key_get_fake; + elm_win_aux_msg_val_get_fake.custom_fake = __elm_win_aux_msg_val_get_fake; + + Evas_Object* bindwin = elm_win_add(NULL, "Bind Window", ELM_WIN_BASIC); + EXPECT_NE(WatchTest::stub, nullptr); + WatchTest::stub->Bind(bindwin); +} + +TEST_F(WatchTest, OnEvasAdded) { + EXPECT_NE(WatchTest::stub, nullptr); + WatchTest::stub->InvokeEvasAdded(); +} + +TEST_F(WatchTest, OnEvasRemoved) { + EXPECT_NE(WatchTest::stub, nullptr); + WatchTest::stub->InvokeEvasRemoved(); +} + +TEST_F(WatchTest, OnEvasChanged) { + EXPECT_NE(WatchTest::stub, nullptr); + WatchTest::stub->InvokeEvasChanged(); } \ No newline at end of file diff --git a/unittest/src/test_watch_holder.cc b/unittest/src/test_watch_holder.cc index aa6a863a..6d119776 100644 --- a/unittest/src/test_watch_holder.cc +++ b/unittest/src/test_watch_holder.cc @@ -34,34 +34,51 @@ class WatchHolderStub : public WatchHolder { : WatchHolder(win) { } - void OnAmbientChanged(bool enter, Bundle& extra) override {} - void OnAmbientEvent(EventType ev, string sender, - Bundle extra) override {} + void InvokeAmbientChanged(bool enter, Bundle& extra) { + OnAmbientChanged(enter, extra); + } + void InvokeAmbientEvent(EventType ev, string sender, + Bundle extra) { + OnAmbientEvent(ev, sender, extra); + } void OnAdded(const Watch& watch) override {} void OnUpdated(const Watch& watch) override {} void OnRemoved(const Watch& watch) override {} void OnLaunched(const Watch& watch) override {} void OnDead(const Watch& watch) override {} void OnBound(const Watch& watch) override {} + + std::shared_ptr CreateWatch(int rid, std::string id, + std::string appid, Evas_Object* viewer_win, + Watch::IEvent* listener, bool mock) override { + return WatchHolder::CreateWatch(rid, id, appid, viewer_win, listener, true); + } + std::shared_ptr CreateWatch(int rid, std::string id, + std::string appid, Evas_Object* viewer_win, tizen_base::Bundle extra, + Watch::IEvent* listener, bool mock) override { + return WatchHolder::CreateWatch(rid, id, appid, viewer_win, extra, listener, true); + } + }; static int (*__app_com_cb)(const char *endpoint, aul_app_com_result_e result, bundle *envelope, void *user_data); static Bundle b; static string global_end; +aul_app_com_connection_h *global_conn; static int __aul_app_get_appid_bypid_fake(int pid, char* appid, int len) { - snprintf(appid, len, "%s", "org.tizen.test"); + snprintf(appid, len, "%s", "org.tizen.watch"); return 0; } static int __aul_app_com_create_fake(const char* end, aul_app_com_permission_h permission, app_com_cb cb, void* user_data, aul_app_com_connection_h* conn) { - *conn = nullptr; + *conn = *global_conn; b = Bundle(); - b.Add("__AUL_APPID__", "appid"); + b.Add("__AUL_APPID__", "org.tizen.watch"); b.Add("__AUL_PID__", "111"); b.Add("__AUL_IS_FAULT__", "is_fault"); - b.Add("__AUL_WIDGET_VIEWER__", "fake"); + b.Add("__AUL_WIDGET_VIEWER__", "org.tizen.watch"); b.Add("__AMBIENT_MODE__", "100"); b.Add("__APP_AMBIENT_EVENT__", "0"); b.Add("__APP_AMBIENT_SENDER__", "sender"); @@ -87,11 +104,13 @@ class WatchHolderTest : public ::testing::Test { aul_app_com_create_fake.custom_fake = __aul_app_com_create_fake; aul_app_com_leave_fake.custom_fake = __aul_app_com_leave_fake; aul_app_get_appid_bypid_fake.custom_fake = __aul_app_get_appid_bypid_fake; + global_conn = (aul_app_com_connection_h*)malloc(sizeof(aul_app_com_connection_h)); Evas_Object* win = elm_win_add(NULL, "Watch Holder", ELM_WIN_BASIC); stub = new WatchHolderStub(win); } virtual void TearDown() { + free(global_conn); delete stub; } }; @@ -100,6 +119,21 @@ TEST_F(WatchHolderTest, CreateInstance) { EXPECT_NE(WatchHolderTest::stub, nullptr); } +TEST_F(WatchHolderTest, CreateWatch) { + Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC); + std::shared_ptr w = + WatchHolderTest::stub->CreateWatch(1, string("id"), string("appid"), + watchwin, WatchHolderTest::stub, true); + EXPECT_NE(w, nullptr); + + Bundle b; + b.Add("__APP_AMBIENT_EVENT__", "1"); + std::shared_ptr w2 = + WatchHolderTest::stub->CreateWatch(1, string("id"), string("appid"), + watchwin, b, WatchHolderTest::stub, true); + EXPECT_NE(w2, nullptr); +} + TEST_F(WatchHolderTest, LaunchWatch) { appsvc_run_service_fake.custom_fake = __appsvc_run_service_fake; string appid("org.tizen.watch"); @@ -122,6 +156,14 @@ TEST_F(WatchHolderTest, GetCurrent_N) { TEST_F(WatchHolderTest, OnLaunchSignal) { EXPECT_NE(WatchHolderTest::stub, nullptr); + int ret; + string appid("org.tizen.watch"); + ret = WatchHolderTest::stub->Launch(appid, false, b.GetHandle()); + EXPECT_NE(ret, -1); + __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub); + + ret = WatchHolderTest::stub->Launch(appid, false, nullptr); + EXPECT_NE(ret, -1); __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub); global_end = "watch.dead"; } @@ -141,4 +183,27 @@ TEST_F(WatchHolderTest, OnAmbientChangedSignal) { TEST_F(WatchHolderTest, OnReceiveSignal) { EXPECT_NE(WatchHolderTest::stub, nullptr); __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub); +} + +TEST_F(WatchHolderTest, EnableRendering) { + EXPECT_NE(WatchHolderTest::stub, nullptr); + WatchHolderTest::stub->EnableRendering(); +} + +TEST_F(WatchHolderTest, DisableRendering) { + EXPECT_NE(WatchHolderTest::stub, nullptr); + WatchHolderTest::stub->DisableRendering(0); +} + +TEST_F(WatchHolderTest, OnAmbientChanged) { + Bundle *b = nullptr; + EXPECT_NE(WatchHolderTest::stub, nullptr); + WatchHolderTest::stub->InvokeAmbientChanged(true, *b); +} + +TEST_F(WatchHolderTest, OnAmbientEvent) { + Bundle b; + b.Add("__APP_AMBIENT_EVENT__", "1"); + EXPECT_NE(WatchHolderTest::stub, nullptr); + WatchHolderTest::stub->InvokeAmbientEvent(AmbientListener::EVENT_AOD_READY, string("sender"), b); } \ No newline at end of file diff --git a/unittest/src/test_watch_mirror.cc b/unittest/src/test_watch_mirror.cc index 26f11c55..a8e3774c 100644 --- a/unittest/src/test_watch_mirror.cc +++ b/unittest/src/test_watch_mirror.cc @@ -38,11 +38,30 @@ class WatchMirrorStub : public WatchMirror { void OnRemoved(const ISharableWatch& watch) override {} }; +class SharableWatchStub : public ISharableWatch { + public: + + void Resume() override; + void Pause() override; + Evas_Object* GetCurrentImage() const override; + bool IsBound() const override; + std::string GetAppId() const override; + int GetPid() const override; + tizen_base::Bundle GetExtra() const override; + bool IsFaulted() const override; + void BlockUpdate(bool enable) override; +}; + static int __vconf_notify_key_changed_fake(const char* key, vconf_callback_fn cb, void* data) { return 0; } +static int __vconf_notify_key_changed_fake2(const char* key, vconf_callback_fn cb, + void* data) { + return -1; +} + static char* __vconf_get_str_fake(const char* key) { bundle_raw* raw; int len; @@ -83,8 +102,80 @@ TEST_F(WatchMirrorTest, MirrorListen) { EXPECT_EQ(ret, 0); } +TEST_F(WatchMirrorTest, MirrorListen_N) { + int ret; + + vconf_notify_key_changed_fake.custom_fake = __vconf_notify_key_changed_fake2; + + ret = WatchMirrorTest::mirrorstub->Listen(); + EXPECT_NE(ret, 0); +} + TEST_F(WatchMirrorTest, MirrorGetCurrent_N) { shared_ptr sw; sw = WatchMirrorTest::mirrorstub->GetCurrent(); EXPECT_EQ(sw, nullptr); } + +TEST_F(WatchMirrorTest, OnChanged) { + Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC); + Watch *w = new Watch(string("test"), watchwin, WatchMirrorTest::mirrorstub); + EXPECT_NE(w, nullptr); + WatchMirror *mr = new WatchMirror(watchwin); + EXPECT_NE(mr, nullptr); + mr->OnChanged(*w); + delete w; + delete mr; +} + +TEST_F(WatchMirrorTest, OnAdded) { + Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC); + SharableWatchStub *w = nullptr; + + WatchMirror *mr = new WatchMirror(watchwin); + EXPECT_NE(mr, nullptr); + mr->OnAdded(*w); + + delete mr; +} + +TEST_F(WatchMirrorTest, OnUpdated) { + Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC); + SharableWatchStub *w = nullptr; + + WatchMirror *mr = new WatchMirror(watchwin); + EXPECT_NE(mr, nullptr); + mr->OnUpdated(*w); + + delete mr; +} + +TEST_F(WatchMirrorTest, OnRemoved) { + Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC); + SharableWatchStub *w = nullptr; + + WatchMirror *mr = new WatchMirror(watchwin); + EXPECT_NE(mr, nullptr); + mr->OnRemoved(*w); + + delete mr; +} + +TEST_F(WatchMirrorTest, OnAmbientChanged) { + Bundle *b = nullptr; + Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC); + WatchMirror *mr = new WatchMirror(watchwin); + EXPECT_NE(mr, nullptr); + mr->OnAmbientChanged(true, *b); + delete mr; +} + +TEST_F(WatchMirrorTest, OnAmbientEvent) { + Bundle b; + b.Add("__APP_AMBIENT_EVENT__", "1"); + Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC); + WatchMirror *mr = new WatchMirror(watchwin); + EXPECT_NE(mr, nullptr); + mr->OnAmbientEvent(AmbientListener::EVENT_AOD_READY, string("sender"), b); + delete mr; +} \ No newline at end of file diff --git a/watch-holder/src/watch.hh b/watch-holder/src/watch.hh index 5e168cc1..8e935187 100644 --- a/watch-holder/src/watch.hh +++ b/watch-holder/src/watch.hh @@ -64,7 +64,7 @@ class EXPORT_API Watch : private screen_connector::RemoteSurfaceEvas, bool IsFaulted() const override; void BlockUpdate(bool enable) override; - private: + protected: friend class WatchHolder; void OnEvasAdded(const std::string& appId, const std::string& instId, int pid, const screen_connector::EvasObject& image) override; diff --git a/watch-holder/src/watch_holder.cc b/watch-holder/src/watch_holder.cc index 5fa82ac8..ff7afac3 100644 --- a/watch-holder/src/watch_holder.cc +++ b/watch-holder/src/watch_holder.cc @@ -59,6 +59,32 @@ WatchHolder::WatchHolder(Evas_Object* win) : win_(win) { appid_ = appid_buf; } +std::shared_ptr WatchHolder::CreateWatch(std::string appid, + Evas_Object* viewer_win, Watch::IEvent* listener, bool mock) { + return make_shared(std::move(appid), viewer_win, listener, mock); +} + +std::shared_ptr WatchHolder::CreateWatch(int rid, std::string id, + std::string appid, Evas_Object* viewer_win, Watch::IEvent* listener, + bool mock) { + return make_shared(rid, std::move(id), std::move(appid), viewer_win, + listener, mock); +} + +std::shared_ptr WatchHolder::CreateWatch(std::string appid, + Evas_Object* viewer_win, tizen_base::Bundle extra, + Watch::IEvent* listener, bool mock) { + return make_shared(std::move(appid), viewer_win, std::move(extra), + listener, mock); +} + +std::shared_ptr WatchHolder::CreateWatch(int rid, std::string id, + std::string appid, Evas_Object* viewer_win, tizen_base::Bundle extra, + Watch::IEvent* listener, bool mock) { + return make_shared(rid, std::move(id), std::move(appid), viewer_win, + std::move(extra), listener, mock); +} + int WatchHolder::Launch( string watch_appid, bool background, bundle* extra) { Evas_Coord x, y, w, h; @@ -147,10 +173,10 @@ int WatchHolder::OnLaunchSignal(const char *endpoint, if (holder->extra_map_.find(watch_appid) != holder->extra_map_.end()) { Bundle extra(holder->extra_map_[watch_appid]); - holder->stack_.push_back(make_shared(watch_appid, holder->win_, extra, holder)); + holder->stack_.push_back(holder->CreateWatch(watch_appid, holder->win_, extra, holder)); holder->extra_map_.erase(watch_appid); } else { - holder->stack_.push_back(make_shared(watch_appid, holder->win_, holder)); + holder->stack_.push_back(holder->CreateWatch(watch_appid, holder->win_, holder)); } holder->OnLaunched(*holder->GetCurrent()); LOGI("LAUNCH DONE (%s)", viewer_appid.c_str()); diff --git a/watch-holder/src/watch_holder.hh b/watch-holder/src/watch_holder.hh index ce81d66c..e4b61a39 100644 --- a/watch-holder/src/watch_holder.hh +++ b/watch-holder/src/watch_holder.hh @@ -48,6 +48,19 @@ class EXPORT_API WatchHolder : public Watch::IEvent, public AmbientListener { virtual void OnAmbientEvent(EventType ev, std::string sender, tizen_base::Bundle extra) override; + protected: + virtual std::shared_ptr CreateWatch(std::string appid, + Evas_Object* viewer_win, Watch::IEvent* listener, bool mock = false); + virtual std::shared_ptr CreateWatch(int rid, std::string id, + std::string appid, Evas_Object* viewer_win, Watch::IEvent* listener, + bool mock = false); + virtual std::shared_ptr CreateWatch(std::string appid, + Evas_Object* viewer_win, tizen_base::Bundle extra, + Watch::IEvent* listener, bool mock = false); + virtual std::shared_ptr CreateWatch(int rid, std::string id, + std::string appid, Evas_Object* viewer_win, tizen_base::Bundle extra, + Watch::IEvent* listener, bool mock = false); + private: static int OnDeadSignal(const char *endpoint, aul_app_com_result_e e, bundle *envelope, void *user_data);