From 65c05528a11f7febf548559692b526a28cd49a58 Mon Sep 17 00:00:00 2001 From: Igor Olshevskyi Date: Wed, 17 May 2017 13:24:06 +0300 Subject: [PATCH] TizenRefApp-8521 [Call UI] Implement RejectMsgPresenter Change-Id: Id77b4c6cd285fbd4aa10bc6aeba33fdc129dd40c --- edc/color_classes.edc | 3 + edc/images/b_ic_press_full_circle_bg.png | Bin 0 -> 7317 bytes edc/layouts.edc | 12 +- edc/reject_msg.edc | 116 ++++++ inc/model/ICallInfo.h | 4 + inc/presenters/AcceptDialog.h | 2 +- inc/presenters/CallStatus.h | 4 +- inc/presenters/MainPage.h | 15 +- inc/presenters/Page.hpp | 2 +- inc/presenters/RejectMsgPresenter.h | 113 ++++++ inc/presenters/types.h | 10 + inc/resources.h | 2 + res/edje/theme.edc | 1 + src/model/CallInfo.cpp | 9 + src/presenters/AcceptDialog.cpp | 20 +- src/presenters/AcceptRejectPresenter.cpp | 17 +- src/presenters/CallInfoPresenter.cpp | 12 +- src/presenters/CallStatus.cpp | 2 +- src/presenters/MainPage.cpp | 123 +++++- src/presenters/RejectMsgPresenter.cpp | 464 +++++++++++++++++++++++ src/presenters/helpers.cpp | 39 ++ src/presenters/helpers.h | 28 ++ src/resources.cpp | 2 + 23 files changed, 969 insertions(+), 31 deletions(-) create mode 100644 edc/images/b_ic_press_full_circle_bg.png create mode 100644 edc/reject_msg.edc create mode 100644 inc/presenters/RejectMsgPresenter.h create mode 100644 src/presenters/RejectMsgPresenter.cpp create mode 100644 src/presenters/helpers.cpp create mode 100644 src/presenters/helpers.h diff --git a/edc/color_classes.edc b/edc/color_classes.edc index df4e2d2..eb27b05 100644 --- a/edc/color_classes.edc +++ b/edc/color_classes.edc @@ -72,4 +72,7 @@ color_classes { color_class { name: "AO0311D"; color: 255 255 255 77; } + color_class { name: "AO029"; + color: 255 255 255 204; + } } diff --git a/edc/images/b_ic_press_full_circle_bg.png b/edc/images/b_ic_press_full_circle_bg.png new file mode 100644 index 0000000000000000000000000000000000000000..5b9f7e44474bd0213f3f346ddde3f0e9c4247460 GIT binary patch literal 7317 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 literal 0 HcmV?d00001 diff --git a/edc/layouts.edc b/edc/layouts.edc index fb1b3bc..99443fc 100644 --- a/edc/layouts.edc +++ b/edc/layouts.edc @@ -63,11 +63,21 @@ group { "elm/layout/callui/main"; desc { "default"; } } + swallow { "swl.rm" + scale; + desc { "default"; + } + } swallow { "swl.accept_reject"; scale; desc { "default"; } } + swallow { "swl.overlay"; + scale; + desc { "default"; + } + } } } @@ -217,4 +227,4 @@ group { "elm/layout/callui/indicator"; } } } -} \ No newline at end of file +} diff --git a/edc/reject_msg.edc b/edc/reject_msg.edc new file mode 100644 index 0000000..4e1a4b0 --- /dev/null +++ b/edc/reject_msg.edc @@ -0,0 +1,116 @@ +/* + * Copyright 2017 Samsung Electronics Co., Ltd + * + * Licensed under the Flora License, Version 1.1 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://floralicense.org/license/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +styles { + style { + name: "ATO27"; + base: "font=Tizen font_weight=Regular font_width=Condensed font_size=24 align=center valign=center color=#FFFFFF7F ellipsis=1.0"; + } +} + +group { "elm/layout/callui/reject_msg"; + images { + image: "Incoming/w_call_alarm_message_cue.png" COMP; + } + parts { + spacer { "bg"; + scale; + desc { "default"; + } + } + spacer { "cue.bottom.pad"; + scale; + desc { "default"; + align: 0.5 1.0; + fixed: 0 1; + min: 0 15; + rel1 { relative: 0.0 1.0; to: "bg"; } + rel2 { relative: 1.0 1.0; to: "bg"; } + } + } + image { "cue"; + repeat; + desc { "default"; + align: 0.5 1.0; + fixed: 0 1; + min: 32 18; + max: 32 18; + fixed: 0 1; + rel1 { relative: 0.0 0.0; to: "cue.bottom.pad"; } + rel2 { relative: 1.0 0.0; to: "cue.bottom.pad"; } + image.normal : "Incoming/w_call_alarm_message_cue.png"; + color_class: AO029; + vis; + } + desc { "hide";; + inherit: "default" 0.0; + hid; + } + } + spacer { "reject_msg_text_zone"; + scale; + desc { "default"; + fixed: 0 1; + align: 0.5 1.0; + min: 208 32; + max: 208 32; + rel1 { relative: 0.0 0.0; to: "cue"; } + rel2 { relative: 1.0 0.0; to: "cue"; } + } + } + textblock { "reject_msg_text"; + scale; + nomouse; + repeat; + desc { "default"; + rel1 { relative: 0.0 0.0; to: "reject_msg_text_zone"; } + rel2 { relative: 1.0 1.0; to: "reject_msg_text_zone"; } + text.style: "ATO27"; + text.min: 1 0; + vis; + } + desc { "hide"; + inherit: "default" 0.0; + hid; + } + } + } +} + +group { "elm/layout/callui/rm_panel_content"; + images.image: "b_ic_press_full_circle_bg.png" COMP; + parts { + image { "cid_clipper"; + precise_is_inside: 1; + desc { "default"; + rel1 { relative: 0.0 0.0; } + rel2 { relative: 1.0 1.0; } + image.normal: "b_ic_press_full_circle_bg.png"; + aspect: 1.0 1.0; + aspect_preference: SOURCE; + } + } + swallow { "elm.swallow.content"; + scale; + clip_to: "cid_clipper"; + desc { "default"; + min: CU_WIN_W CU_WIN_H; + max: CU_WIN_W CU_WIN_H; + } + } + } +} diff --git a/inc/model/ICallInfo.h b/inc/model/ICallInfo.h index 8088931..7c1d4fd 100644 --- a/inc/model/ICallInfo.h +++ b/inc/model/ICallInfo.h @@ -34,6 +34,10 @@ namespace callui { virtual int getConferenceMemberCount() const = 0; virtual const ConfMemberList &getConferenceMemberList() const = 0; }; + + // Non-member functions + + bool isUnknownCaller(const ICallInfo &info); } #endif // __CALLUI_MODEL_I_CALL_INFO_H__ diff --git a/inc/presenters/AcceptDialog.h b/inc/presenters/AcceptDialog.h index 1efaa4f..1e33326 100644 --- a/inc/presenters/AcceptDialog.h +++ b/inc/presenters/AcceptDialog.h @@ -70,7 +70,7 @@ namespace callui { void onPopupDismissed(ucl::Widget &widget, void *eventInfo); void onPopupHWBackKey(Evas_Object *obj, void *eventInfo); - void onGenlistItemClickedCb(Evas_Object *obj, void *event_info); + void onGenlistItemClickedCb(Evas_Object *obj, void *eventInfo); private: ucl::StyledWidgetSRef m_popup; diff --git a/inc/presenters/CallStatus.h b/inc/presenters/CallStatus.h index 3e4bf4c..62bdad4 100644 --- a/inc/presenters/CallStatus.h +++ b/inc/presenters/CallStatus.h @@ -17,6 +17,8 @@ #ifndef __CALLUI_PRESENTERS_CALL_STATUS_H__ #define __CALLUI_PRESENTERS_CALL_STATUS_H__ +#include "Presenter.h" + #include #include "ucl/gui/Layout.h" @@ -25,7 +27,7 @@ namespace callui { - class CallStatus final : public ucl::RefCountAware { + class CallStatus final : public Presenter { public: class Builder { public: diff --git a/inc/presenters/MainPage.h b/inc/presenters/MainPage.h index 1ff6005..43055a3 100644 --- a/inc/presenters/MainPage.h +++ b/inc/presenters/MainPage.h @@ -50,9 +50,20 @@ namespace callui { ucl::Result prepare(); + ucl::Result processIncomingCall(const IIncomingCallSRef &incom); + ucl::Result createAcceptRejectPresenter(); + ucl::Result createRejectMsgPresenter(const IIncomingCallSRef &incom); ucl::Result createCallInfoPresenter(CallInfoMode mode); + void RejectMsgStateCb(RejectMsgState state); + void RejectMsgSelectCb(const IRejectMsgSRef &rm); + + // Presenter + + virtual void onActivateBy(const DeactivatorInfo &info) final override; + virtual void onDeactivateBy(const DeactivatorInfo &info) final override; + // Page virtual void onBackKey() final override; @@ -64,10 +75,12 @@ namespace callui { private: ucl::LayoutSRef m_widget; + ucl::LayoutSRef m_rmLy; ICallSRef m_call; IndicatorSRef m_indicator; CallInfoPresenterSRef m_callInfoPrs; - AcceptRejectPresenterSRef m_acceptReject; + AcceptRejectPresenterSRef m_acceptRejectPrs; + RejectMsgPresenterSRef m_rmPrs; }; } diff --git a/inc/presenters/Page.hpp b/inc/presenters/Page.hpp index 2f777e4..7ee2a56 100644 --- a/inc/presenters/Page.hpp +++ b/inc/presenters/Page.hpp @@ -56,7 +56,7 @@ namespace callui { return (m_navi->getBottomItem() == m_item); } - // Non-member functions // + // Non-member functions inline bool isLast(const Page &page) { diff --git a/inc/presenters/RejectMsgPresenter.h b/inc/presenters/RejectMsgPresenter.h new file mode 100644 index 0000000..4a454ee --- /dev/null +++ b/inc/presenters/RejectMsgPresenter.h @@ -0,0 +1,113 @@ +/* + * Copyright 2017 Samsung Electronics Co., Ltd + * + * Licensed under the Flora License, Version 1.1 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://floralicense.org/license/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CALLUI_PRESENTERS_REJECT_MESSAGE_PRESENTER_H__ +#define __CALLUI_PRESENTERS_REJECT_MESSAGE_PRESENTER_H__ + +#include "Presenter.h" + +#include "ucl/gui/Layout.h" +#include "ucl/gui/StyledWidget.h" + +#include "types.h" + +namespace callui { + + class RejectMsgPresenter final : public Presenter { + public: + class Builder { + public: + Builder(); + virtual ~Builder(); + Builder &setProvider(const IRejectMsgProviderSRef &provider); + Builder &setStateHandler(const RejectMsgStateHandler &handler); + Builder &setSelectHandler(const RejectMsgSelectHandler &handler); + RejectMsgPresenterSRef build(ucl::ElmWidget &parent) const; + + private: + IRejectMsgProviderSRef m_provider; + RejectMsgStateHandler m_stateHandler; + RejectMsgSelectHandler m_selectHandler; + }; + + public: + virtual ~RejectMsgPresenter(); + + ucl::Widget &getWidget(); + + RejectMsgState getState(); + + void hidePanel(); + + void setStateHandler(const RejectMsgStateHandler &handler); + void setSelectHandler(const RejectMsgSelectHandler &handler); + + private: + class RejectMsgItem; + + private: + friend class ucl::RefCountObj; + RejectMsgPresenter(ucl::RefCountObjBase &rc, + const IRejectMsgProviderSRef &provider, + const RejectMsgStateHandler &stateHandler, + const RejectMsgSelectHandler &selectHandler); + + ucl::Result prepare(ucl::ElmWidget &parent); + + ucl::Result createWidget(ucl::ElmWidget &parent); + ucl::Result createPanel(); + ucl::Result createPanelBg(); + ucl::Result createPanelLy(); + ucl::Result createGenlist(); + ucl::Result fillGenlist(); + + ucl::Result addGenlistTitleItem(); + ucl::Result addGenlistTextItem(const IRejectMsgSRef &rm); + ucl::Result addGenlistBottomItem(); + + void onGenlistItemClickedCb(Evas_Object *obj, void *eventInfo); + void handleSelectEvent(const RejectMsgItem &item); + + void panelScrollCb(ucl::Widget &widget, void *eventInfo); + + void activateRotary(); + void deactivateRotary(); + + void onBackKey(Evas_Object *obj, void *eventInfo); + + // Presenter + + virtual void onActivate() final override; + virtual void onDeactivate() final override; + + private: + ucl::LayoutSRef m_widget; + ucl::StyledWidgetSRef m_panel; + ucl::ElmWidgetSRef m_panelBg; + ucl::LayoutSRef m_panelLy; + ucl::StyledWidgetSRef m_genlist; + Evas_Object *m_circleEo; + + IRejectMsgProviderSRef m_provider; + RejectMsgStateHandler m_stateHandler; + RejectMsgSelectHandler m_selectHandler; + RejectMsgState m_state; + + }; + +} + +#endif // __CALLUI_PRESENTERS_REJECT_MESSAGE_PRESENTER_H__ diff --git a/inc/presenters/types.h b/inc/presenters/types.h index f793cfc..052dfbf 100644 --- a/inc/presenters/types.h +++ b/inc/presenters/types.h @@ -38,6 +38,12 @@ namespace callui { END }; + enum class RejectMsgState { + HIDDEN, + IN_TRANSITION, + SHOWN + }; + UCL_DECLARE_REF_ALIASES(Page); UCL_DECLARE_REF_ALIASES(MainPage); @@ -48,7 +54,11 @@ namespace callui { UCL_DECLARE_REF_ALIASES(CallInfoPresenter); UCL_DECLARE_REF_ALIASES(CallStatus); + UCL_DECLARE_REF_ALIASES(RejectMsgPresenter); + using AcceptDialogHandler = ucl::WeakDelegate; + using RejectMsgStateHandler = ucl::WeakDelegate; + using RejectMsgSelectHandler = ucl::WeakDelegate; } #endif // __CALLUI_PRESENTERS_TYPES_H__ diff --git a/inc/resources.h b/inc/resources.h index 0b89fc7..84f9354 100644 --- a/inc/resources.h +++ b/inc/resources.h @@ -40,6 +40,8 @@ namespace callui { extern const ucl::TString STR_DIALING_CALL; extern const ucl::TString STR_ON_HOLD; extern const ucl::TString STR_CALL_ENDED; + + extern const ucl::TString STR_DECLINE_MESSAGES; } #endif // __CALLUI_RESOURCES_H__ diff --git a/res/edje/theme.edc b/res/edje/theme.edc index 1f05ee2..33a4543 100644 --- a/res/edje/theme.edc +++ b/res/edje/theme.edc @@ -45,5 +45,6 @@ collections { #include "../../edc/indicator.edc" #include "../../edc/call_info.edc" + #include "../../edc/reject_msg.edc" } diff --git a/src/model/CallInfo.cpp b/src/model/CallInfo.cpp index 9e70afe..c31d68b 100644 --- a/src/model/CallInfo.cpp +++ b/src/model/CallInfo.cpp @@ -213,4 +213,13 @@ namespace callui { return m_confMemberList; } + // Non-member functions + + bool isUnknownCaller(const ICallInfo &info) + { + auto contactInfo = info.getContactInfo(); + return (info.getPhoneNumber().empty() && + (!contactInfo || contactInfo->getName().empty())); + } + } diff --git a/src/presenters/AcceptDialog.cpp b/src/presenters/AcceptDialog.cpp index e2687d6..ab9731f 100644 --- a/src/presenters/AcceptDialog.cpp +++ b/src/presenters/AcceptDialog.cpp @@ -27,6 +27,8 @@ namespace callui { namespace { namespace impl { constexpr SmartEvent POPUP_DISMISSED {"dismissed"}; + constexpr EdjePart PART_SWL_CONTENT{"elm.swallow.content"}; + void *asData(const AcceptDialogEvent event) { return reinterpret_cast(static_cast(event)); @@ -96,6 +98,9 @@ namespace callui { m_rc->ref(); + addDeactivatorException(this); + broadcastDeactivateBy(this); + return RES_OK; } @@ -121,12 +126,12 @@ namespace callui { return RES_OK; } - void AcceptDialog::onGenlistItemClickedCb(Evas_Object *obj, void *event_info) + void AcceptDialog::onGenlistItemClickedCb(Evas_Object *obj, void *eventInfo) { - if (!event_info) - LOG_RETURN_VOID(RES_FAIL, "event_info is NULL"); + if (!eventInfo) + LOG_RETURN_VOID(RES_FAIL, "eventInfo is NULL"); - Elm_Object_Item *item = static_cast(event_info); + Elm_Object_Item *item = static_cast(eventInfo); handleEvent(impl::asEvent(elm_object_item_data_get(item))); } @@ -149,8 +154,7 @@ namespace callui { FAIL_RETURN(fillGenlist(), "fillGenlist() failed!"); - EdjePart content{"elm.swallow.content"}; - m_popup->setContent(glEo, content); + m_popup->setContent(glEo, impl::PART_SWL_CONTENT); return RES_OK; } @@ -265,6 +269,7 @@ namespace callui { { if (m_popup && !m_isDismissed) { m_isDismissed = true; + deactivateBy(m_popup.get()); elm_popup_dismiss(*m_popup); } } @@ -276,6 +281,9 @@ namespace callui { eext_object_event_callback_del(*m_popup, EEXT_CALLBACK_BACK, CALLBACK_A(AcceptDialog::onPopupHWBackKey)); + deactivateBy(m_popup.get()); + broadcastActivateBy(this); + m_popup.reset(); m_rc->unref(); diff --git a/src/presenters/AcceptRejectPresenter.cpp b/src/presenters/AcceptRejectPresenter.cpp index dd5a8d0..93c18fa 100644 --- a/src/presenters/AcceptRejectPresenter.cpp +++ b/src/presenters/AcceptRejectPresenter.cpp @@ -107,13 +107,17 @@ namespace callui { Result AcceptRejectPresenter::prepare(ElmWidget &parent) { - FAIL_RETURN(Presenter::prepare(parent), "Presenter::prepare() failed!"); + FAIL_RETURN(Presenter::prepare(parent), + "Presenter::prepare() failed!"); - FAIL_RETURN(createWidget(parent), "createWidget() failed!"); + FAIL_RETURN(createWidget(parent), + "createWidget() failed!"); - FAIL_RETURN(createAcceptBtn(), "createAcceptBtn() failed!"); + FAIL_RETURN(createAcceptBtn(), + "createAcceptBtn() failed!"); - FAIL_RETURN(createRejectBtn(), "createRejectBtn() failed!"); + FAIL_RETURN(createRejectBtn(), + "createRejectBtn() failed!"); addRotaryEventHandler(CALLBACK_A( AcceptRejectPresenter::onRotaryEvent), this); @@ -220,8 +224,9 @@ namespace callui { Eina_Bool AcceptRejectPresenter::onRotaryEvent(Eext_Rotary_Event_Info *info) { - if (m_popup) - LOG_RETURN_VALUE(RES_OK, EINA_TRUE, "Popup is shown. Ignore"); + if (!isActive()) { + LOG_RETURN_VALUE(RES_OK, EINA_TRUE, "Presenter is not active. Ignore"); + } if (info->direction == EEXT_ROTARY_DIRECTION_CLOCKWISE) { m_reject->emit(impl::SIGNAL_BTN_UNPRESS); diff --git a/src/presenters/CallInfoPresenter.cpp b/src/presenters/CallInfoPresenter.cpp index d105717..37e518a 100644 --- a/src/presenters/CallInfoPresenter.cpp +++ b/src/presenters/CallInfoPresenter.cpp @@ -140,11 +140,14 @@ namespace callui { Result CallInfoPresenter::prepare(ElmWidget &parent) { - FAIL_RETURN(Presenter::prepare(parent), "Presenter::prepare() failed!"); + FAIL_RETURN(Presenter::prepare(parent), + "Presenter::prepare() failed!"); - FAIL_RETURN(createWidget(parent), "createWidget() failed!"); + FAIL_RETURN(createWidget(parent), + "createWidget() failed!"); - FAIL_RETURN(createCallStatus(), "createCallStatus() failed!"); + FAIL_RETURN(createCallStatus(), + "createCallStatus() failed!"); FAIL_RETURN(update(), "update() failed!"); @@ -268,9 +271,10 @@ namespace callui { if (confMemberCount > 1) { return TString{STR_WITH_PD_PEOPLE.translate()}.format(confMemberCount); } + } else { + ELOG("Invalid call data"); } - ELOG("Invalid call data"); return ""; } diff --git a/src/presenters/CallStatus.cpp b/src/presenters/CallStatus.cpp index d6a8d52..0499dbe 100644 --- a/src/presenters/CallStatus.cpp +++ b/src/presenters/CallStatus.cpp @@ -125,7 +125,7 @@ namespace callui { CallInfoMode mode, const ICallInfoWCRef &info, bool isHeld): - RefCountAware(&rc), + Presenter(rc), m_ly(layout), m_mode(mode), m_info(info), diff --git a/src/presenters/MainPage.cpp b/src/presenters/MainPage.cpp index 07218bc..fbaf264 100644 --- a/src/presenters/MainPage.cpp +++ b/src/presenters/MainPage.cpp @@ -18,6 +18,7 @@ #include "ucl/gui/Window.h" #include "ucl/gui/Layout.h" +#include "ucl/gui/Widget.h" #include "model/ICall.h" #include "model/ICallManager.h" @@ -26,11 +27,14 @@ #include "model/IHeldCall.h" #include "model/IEndCall.h" #include "model/IIndicatorStateProvider.h" +#include "model/ICallInfo.h" #include "presenters/Indicator.h" #include "presenters/AcceptRejectPresenter.h" #include "presenters/CallInfoPresenter.h" +#include "presenters/RejectMsgPresenter.h" +#include "resources.h" #include "common.h" namespace callui { namespace { namespace impl { @@ -40,10 +44,16 @@ namespace callui { namespace { namespace impl { constexpr LayoutTheme LAYOUT_MAIN_WIDGET {"layout", "callui", "main"}; + constexpr LayoutTheme LAYOUT_REJECT_MSG_WIDGET + {"layout", "callui", "reject_msg"}; + constexpr EdjePart PART_SWL_INDICATOR {"swl.indicator"}; constexpr EdjePart PART_SWL_ACCEPT_REJECT {"swl.accept_reject"}; constexpr EdjePart PART_SWL_CALL_INFO {"swl.call_info"}; + constexpr EdjePart PART_SWL_REJECT_MSG {"swl.rm"}; + constexpr EdjePart PART_SWL_OVERLAY {"swl.overlay"}; + constexpr EdjePart PART_TXT_REJECT_MSG{"reject_msg_text"}; }}} namespace callui { @@ -138,6 +148,32 @@ namespace callui { }); } + void MainPage::onActivateBy(const DeactivatorInfo &info) + { + if (info.deactivator == &getNaviframe()) { + if (m_rmPrs) { + m_rmPrs->activateBy(info.deactivator); + } + } + + if (m_acceptRejectPrs) { + m_acceptRejectPrs->activateBy(info.deactivator); + } + } + + void MainPage::onDeactivateBy(const DeactivatorInfo &info) + { + if (info.deactivator == &getNaviframe()) { + if (m_rmPrs) { + m_rmPrs->deactivateBy(info.deactivator); + } + } + + if (m_acceptRejectPrs) { + m_acceptRejectPrs->deactivateBy(info.deactivator); + } + } + void MainPage::onBackKey() { auto callMng = m_call->getCallManager(); @@ -147,6 +183,30 @@ namespace callui { } } + Result MainPage::processIncomingCall(const IIncomingCallSRef &incom) + { + FAIL_RETURN(createAcceptRejectPresenter(), + "createAcceptRejectPresenter() failed!"); + + if (!isUnknownCaller(*incom->getInfo())) { + m_rmLy = Layout::Builder(). + setTheme(impl::LAYOUT_REJECT_MSG_WIDGET). + setIsOwner(true). + build(*m_widget); + if (!m_rmLy) { + LOG_RETURN(RES_FAIL, "Layout::build() failed!"); + } + m_rmLy->setText(STR_DECLINE_MESSAGES, impl::PART_TXT_REJECT_MSG); + + m_widget->setContent(m_rmLy->getEo(), impl::PART_SWL_REJECT_MSG); + + FAIL_RETURN(createRejectMsgPresenter(incom), + "createRejectMsgPresenter() failed!"); + } + + return RES_OK; + } + void MainPage::onCallEvent(CallEventType type) { ILOG("CallEventType [%d]", static_cast(type)); @@ -170,10 +230,12 @@ namespace callui { } if (incom) { - FAIL_RETURN_VOID(createAcceptRejectPresenter(), - "createAcceptRejectPresenter() failed!"); + FAIL_RETURN_VOID(processIncomingCall(incom), + "processIncomingCall() failed!"); } else { - m_acceptReject.reset(); + m_rmPrs.reset(); + m_acceptRejectPrs.reset(); + m_rmLy.reset(); } CallInfoMode mode = CallInfoMode::UNDEFINED; @@ -202,27 +264,70 @@ namespace callui { { auto callMng = m_call->getCallManager(); - if (m_acceptReject) { - m_acceptReject->update(callMng->getAvailableCalls()); + if (m_acceptRejectPrs) { + m_acceptRejectPrs->update(callMng->getAvailableCalls()); return RES_OK; } - m_acceptReject = AcceptRejectPresenter::Builder(). + m_acceptRejectPrs = AcceptRejectPresenter::Builder(). setIncomingCall(callMng->getIncomingCall()). setAvailableCallsFlag(callMng->getAvailableCalls()). build(*m_widget); - if (!m_acceptReject) { + if (!m_acceptRejectPrs) { LOG_RETURN(RES_FAIL, "AcceptRejectPresenter::Builder().build() failed!"); } - m_widget->setContent(m_acceptReject->getWidget().getEo(), + m_widget->setContent(m_acceptRejectPrs->getWidget().getEo(), impl::PART_SWL_ACCEPT_REJECT); return RES_OK; } + void MainPage::RejectMsgStateCb(RejectMsgState state) + { + if (state == RejectMsgState::HIDDEN) { + show(*m_rmLy); + } else { + hide(*m_rmLy); + } + } + + void MainPage::RejectMsgSelectCb(const IRejectMsgSRef &rm) + { + auto callMng = m_call->getCallManager(); + auto incom = callMng->getIncomingCall(); + + if (incom) { + incom->rejectWithMessage(rm); + } + } + + Result MainPage::createRejectMsgPresenter(const IIncomingCallSRef &incom) + { + m_rmPrs = RejectMsgPresenter::Builder(). + setProvider(incom->getRejectMsgProvider()). + setStateHandler( + WEAK_DELEGATE(MainPage::RejectMsgStateCb, + asWeak(*this))). + setSelectHandler( + WEAK_DELEGATE(MainPage::RejectMsgSelectCb, + asWeak(*this))). + build(*m_widget); + + if (!m_rmPrs) { + LOG_RETURN(RES_FAIL, + "RejectMessagePresenter::build() failed!"); + } + + m_widget->setContent(m_rmPrs->getWidget().getEo(), + impl::PART_SWL_OVERLAY); + addDeactivatorSource(m_rmPrs->getWidget()); + + return RES_OK; + } + Result MainPage::createCallInfoPresenter(CallInfoMode mode) { auto callMng = m_call->getCallManager(); @@ -238,7 +343,7 @@ namespace callui { if (!m_callInfoPrs) { LOG_RETURN(RES_FAIL, - "CallerInfo::Builder().build() failed!"); + "CallerInfo::build() failed!"); } m_widget->setContent(m_callInfoPrs->getWidget().getEo(), impl::PART_SWL_CALL_INFO); diff --git a/src/presenters/RejectMsgPresenter.cpp b/src/presenters/RejectMsgPresenter.cpp new file mode 100644 index 0000000..06e07c1 --- /dev/null +++ b/src/presenters/RejectMsgPresenter.cpp @@ -0,0 +1,464 @@ +/* + * Copyright 2017 Samsung Electronics Co., Ltd + * + * Licensed under the Flora License, Version 1.1 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://floralicense.org/license/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "presenters/RejectMsgPresenter.h" + +#include "model/IRejectMsgProvider.h" +#include "model/IRejectMsg.h" + +#include "helpers.h" +#include "resources.h" +#include "common.h" + +namespace callui { namespace { namespace impl { + + using namespace ucl; + + constexpr LayoutTheme LAYOUT_DRAWER_PANEL + {"layout", "drawer", "panel"}; + + constexpr LayoutTheme LAYOUT_RM_PANEL_CONTENT + {"layout", "callui", "rm_panel_content"}; + + constexpr EdjePart PART_SWL_RIGHT{"elm.swallow.right"}; + constexpr EdjePart PART_SWL_BG{"elm.swallow.bg"}; + constexpr EdjePart PART_SWL_CONTENT{"elm.swallow.content"}; + + constexpr SmartEvent EVENT_SCROLL{"scroll"}; + +}}} + +namespace callui { + + using namespace ucl; + + class RejectMsgPresenter::RejectMsgItem : public NonCopyable { + public: + RejectMsgItem(const IRejectMsgSRef &rm): + m_rm(rm) + { + } + + virtual ~RejectMsgItem() + { + } + + std::string getDisplayText() const + { + auto trnsTxt = TString{m_rm->getText(), true}.translate(); + + auto markupTxt = elm_entry_utf8_to_markup(trnsTxt); + std::string resStr(markupTxt); + replaceSubstringInString(resStr, "
", " "); + free(markupTxt); + + return resStr; + } + + IRejectMsgSRef getRejectMsg() const + { + return m_rm; + } + + private: + IRejectMsgSRef m_rm; + }; + + RejectMsgPresenter::Builder::Builder() + { + } + + RejectMsgPresenter::Builder::~Builder() + { + } + + RejectMsgPresenter::Builder & + RejectMsgPresenter::Builder::setProvider( + const IRejectMsgProviderSRef &provider) + { + m_provider = provider; + return *this; + } + + RejectMsgPresenter::Builder & + RejectMsgPresenter::Builder::setStateHandler( + const RejectMsgStateHandler &handler) + { + m_stateHandler = handler; + return *this; + } + + RejectMsgPresenter::Builder & + RejectMsgPresenter::Builder::setSelectHandler( + const RejectMsgSelectHandler &handler) + { + m_selectHandler = handler; + return *this; + } + + RejectMsgPresenterSRef RejectMsgPresenter::Builder::build( + ElmWidget &parent) const + { + if (!m_provider) { + LOG_RETURN_VALUE(RES_FAIL, {}, "m_provider is NULL"); + } + + auto result = makeShared(m_provider, + m_stateHandler, + m_selectHandler); + FAIL_RETURN_VALUE(result->prepare(parent), {}, + "result->prepare() failed!"); + + return result; + } + + RejectMsgPresenter::RejectMsgPresenter(RefCountObjBase &rc, + const IRejectMsgProviderSRef &provider, + const RejectMsgStateHandler &stateHandler, + const RejectMsgSelectHandler &selectHandler): + Presenter(rc), + m_circleEo(nullptr), + m_provider(provider), + m_stateHandler(stateHandler), + m_selectHandler(selectHandler), + m_state(RejectMsgState::HIDDEN) + { + } + + RejectMsgPresenter::~RejectMsgPresenter() + { + if (m_widget) { + sendActivateBy(*m_widget, this); + } + } + + Result RejectMsgPresenter::prepare(ElmWidget &parent) + { + FAIL_RETURN(Presenter::prepare(parent), + "Presenter::prepare() failed!"); + + FAIL_RETURN(createWidget(parent), + "createWidget() failed!"); + + FAIL_RETURN(createPanel(), + "createPanel() failed!"); + + FAIL_RETURN(createPanelBg(), + "createPanelBg() failed!"); + + FAIL_RETURN(createPanelLy(), + "createPanelLy() failed!"); + + FAIL_RETURN(createGenlist(), + "createGenlist() failed!"); + + deactivateBy(m_widget.get()); + + return RES_OK; + } + + Result RejectMsgPresenter::createWidget(ElmWidget &parent) + { + m_widget = Layout::Builder(). + setTheme(impl::LAYOUT_DRAWER_PANEL). + setIsOwner(true). + build(parent); + + if (!m_widget) { + LOG_RETURN(RES_FAIL, "Layout::build() failed!"); + } + + eext_object_event_callback_add(m_widget->getEo(), EEXT_CALLBACK_BACK, + CALLBACK_A(RejectMsgPresenter::onBackKey), this); + + return RES_OK; + } + + void RejectMsgPresenter::onBackKey(Evas_Object *obj, void *eventInfo) + { + if (isActive()) { + hidePanel(); + } + } + + void RejectMsgPresenter::panelScrollCb(Widget &widget, void *eventInfo) + { + Elm_Panel_Scroll_Info *ev = static_cast(eventInfo); + DLOG("pos x[%f] y[%f]", ev->rel_x, ev->rel_y); + + if (ev->rel_y == 1.0) { + m_state = RejectMsgState::SHOWN; + // Prevent panel scrolling + elm_object_scroll_freeze_push(m_panel->getEo()); + sendDeactivateBy(*m_widget, this); + activateBy(m_widget.get()); + } else if (ev->rel_y == 0.0) { + m_state = RejectMsgState::HIDDEN; + // Scroll genlist to top + elm_scroller_region_show(m_genlist->getEo(), 0, 0, 0, 0); + } else { + m_state = RejectMsgState::IN_TRANSITION; + if (isActive()) { + deactivateBy(m_widget.get()); + sendActivateBy(*m_widget, this); + } + } + + if (m_stateHandler) { + m_stateHandler(m_state); + } + } + + Result RejectMsgPresenter::createPanel() + { + m_panel = makeShared(elm_panel_add(*m_widget), true); + if (!m_panel) { + LOG_RETURN(RES_FAIL, "elm_panel_add() failed!"); + } + elm_panel_scrollable_set(*m_panel, EINA_TRUE); + elm_panel_scrollable_content_size_set(*m_panel, 1.0); + elm_panel_hidden_set(*m_panel, EINA_TRUE); + elm_panel_orient_set(*m_panel, ELM_PANEL_ORIENT_BOTTOM); + show(*m_panel); + + m_panel->addEventHandler(impl::EVENT_SCROLL, + WEAK_DELEGATE(RejectMsgPresenter::panelScrollCb, + asWeak(*this))); + + m_widget->setContent(m_panel->getEo(), impl::PART_SWL_RIGHT); + + return RES_OK; + } + + Result RejectMsgPresenter::createPanelBg() + { + m_panelBg = makeShared( + evas_object_rectangle_add(evas_object_evas_get(*m_widget))); + if (!m_panelBg) { + LOG_RETURN(RES_FAIL, "evas_object_rectangle_add() failed!"); + } + m_panelBg->setColor(0, 0); + show(*m_panelBg); + + m_widget->setContent(m_panelBg->getEo(), impl::PART_SWL_BG); + + return RES_OK; + } + + Result RejectMsgPresenter::createPanelLy() + { + m_panelLy = Layout::Builder(). + setTheme(impl::LAYOUT_RM_PANEL_CONTENT). + setIsOwner(true). + build(*m_panel); + if (!m_panelLy) { + LOG_RETURN(RES_FAIL, "Layout::build failed!"); + } + show(*m_panelLy); + + m_panel->setContent(m_panelLy->getEo()); + + return RES_OK; + } + + Result RejectMsgPresenter::createGenlist() + { + Evas_Object *const glEo = elm_genlist_add(*m_panelLy); + if (!glEo) { + LOG_RETURN(RES_FAIL, "elm_genlist_add() failed!"); + } + evas_object_size_hint_weight_set(glEo, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(glEo, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_genlist_mode_set(glEo, ELM_LIST_COMPRESS); + elm_genlist_homogeneous_set(glEo, EINA_TRUE); + + elm_scroller_policy_set(glEo, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF); + + m_genlist = makeShared(glEo); + + FAIL_RETURN(fillGenlist(), "fillGenlist() failed!"); + + m_panelLy->setContent(glEo, impl::PART_SWL_CONTENT); + + return RES_OK; + } + + Result RejectMsgPresenter::fillGenlist() + { + FAIL_RETURN(addGenlistTitleItem(), "addGenlistTitleItem() failed!"); + + auto msgList = m_provider->getMsgList(); + for (auto &iter : msgList) { + FAIL_RETURN(addGenlistTextItem(iter), "addGenlistTextItem() failed!"); + } + + FAIL_RETURN(addGenlistBottomItem(), "addGenlistBottomItem() failed!"); + + return RES_OK; + } + + Result RejectMsgPresenter::addGenlistTitleItem() + { + static auto titleItc = createGenlistItemClass("title", + [](void *data, Evas_Object *obj, const char *part) -> char * { + return strdup(STR_DECLINE_MESSAGES.translate()); + }); + + auto *item = elm_genlist_item_append(*m_genlist, &titleItc, + nullptr, + nullptr, + ELM_GENLIST_ITEM_NONE, + nullptr, + nullptr); + if (!item) { + LOG_RETURN(RES_FAIL, "elm_genlist_item_append() failed!"); + } + + return RES_OK; + } + + Result RejectMsgPresenter::addGenlistTextItem(const IRejectMsgSRef &rm) + { + static auto textItc = createGenlistItemClass("1text.1icon", + [](void *data, Evas_Object *obj, const char *part) -> char * { + if (!data) { + LOG_RETURN_VALUE(RES_FAIL, nullptr, "Data is NULL"); + } + RejectMsgItem *rm = static_cast(data); + return strdup(rm->getDisplayText().c_str()); + }, + nullptr, + nullptr, + [](void *data, Evas_Object *obj) -> void { + RejectMsgItem *rm = static_cast(data); + delete rm; + }); + + auto *rmItem = new RejectMsgItem(rm); + if (!rmItem) { + LOG_RETURN(RES_FAIL, "Create RejectMsgItem failed!"); + } + + auto *item = elm_genlist_item_append(*m_genlist, &textItc, + static_cast(rmItem), + nullptr, + ELM_GENLIST_ITEM_NONE, + CALLBACK_A(RejectMsgPresenter::onGenlistItemClickedCb), + this); + if (!item) { + delete rmItem; + LOG_RETURN(RES_FAIL, "elm_genlist_item_append() failed!"); + } + + return RES_OK; + } + + Result RejectMsgPresenter::addGenlistBottomItem() + { + static auto paddingItc = createGenlistItemClass("1text.1icon"); + + auto *item = elm_genlist_item_append(*m_genlist, &paddingItc, + nullptr, + nullptr, + ELM_GENLIST_ITEM_NONE, + nullptr, + nullptr); + if (!item) { + LOG_RETURN(RES_FAIL, "elm_genlist_item_append() failed!"); + } + + return RES_OK; + } + + void RejectMsgPresenter::handleSelectEvent(const RejectMsgItem &item) + { + if (m_selectHandler) { + m_selectHandler(item.getRejectMsg()); + } + } + + void RejectMsgPresenter::onGenlistItemClickedCb(Evas_Object *obj, void *eventInfo) + { + if (!eventInfo) { + LOG_RETURN_VOID(RES_FAIL, "eventInfo is NULL"); + } + + auto *item = static_cast(eventInfo); + auto *rmItem = static_cast( + elm_object_item_data_get(item)); + + handleSelectEvent(*rmItem); + } + + Widget &RejectMsgPresenter::getWidget() + { + return *m_widget; + } + + RejectMsgState RejectMsgPresenter::getState() + { + return m_state; + } + + void RejectMsgPresenter::hidePanel() + { + if (m_state == RejectMsgState::SHOWN) { + elm_object_scroll_freeze_pop(m_panel->getEo()); + elm_panel_hidden_set(m_panel->getEo(), EINA_TRUE); + } + } + + void RejectMsgPresenter::setStateHandler( + const RejectMsgStateHandler &handler) + { + m_stateHandler = handler; + } + + void RejectMsgPresenter::setSelectHandler( + const RejectMsgSelectHandler &handler) + { + m_selectHandler = handler; + } + + void RejectMsgPresenter::onActivate() + { + activateRotary(); + } + + void RejectMsgPresenter::onDeactivate() + { + deactivateRotary(); + } + + void RejectMsgPresenter::activateRotary() + { + if (!m_circleEo) { + elm_scroller_policy_set( + m_genlist->getEo(), ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO); + m_circleEo = eext_circle_object_genlist_add( + m_genlist->getEo(), getCircleSurface(*m_genlist)); + eext_circle_object_genlist_scroller_policy_set( + m_circleEo, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO); + } + eext_rotary_object_event_activated_set(m_circleEo, EINA_TRUE); + } + + void RejectMsgPresenter::deactivateRotary() + { + eext_rotary_object_event_activated_set(m_circleEo, EINA_FALSE); + } + +} diff --git a/src/presenters/helpers.cpp b/src/presenters/helpers.cpp new file mode 100644 index 0000000..5e35a14 --- /dev/null +++ b/src/presenters/helpers.cpp @@ -0,0 +1,39 @@ +/* + * Copyright 2017 Samsung Electronics Co., Ltd + * + * Licensed under the Flora License, Version 1.1 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://floralicense.org/license/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "helpers.h" + +#include "common.h" + +namespace callui { + + using namespace ucl; + + void replaceSubstringInString(std::string &str, + const std::string &from, const std::string &to) + { + if (from.empty()) { + LOG_RETURN_VOID(RES_FAIL, "Parameter from is empty"); + } + + size_t start_pos = 0; + while((start_pos = str.find(from, start_pos)) != std::string::npos) { + str.replace(start_pos, from.length(), to); + start_pos += to.length(); + } + } + +} diff --git a/src/presenters/helpers.h b/src/presenters/helpers.h new file mode 100644 index 0000000..1986073 --- /dev/null +++ b/src/presenters/helpers.h @@ -0,0 +1,28 @@ +/* + * Copyright 2017 Samsung Electronics Co., Ltd + * + * Licensed under the Flora License, Version 1.1 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://floralicense.org/license/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __CALLUI_PRESENTERS_HELPERS_H__ +#define __CALLUI_PRESENTERS_HELPERS_H__ + +#include + +namespace callui { + + void replaceSubstringInString(std::string &str, + const std::string &from, const std::string &to); +} + +#endif // __CALLUI_PRESENTERS_HELPERS_H__ diff --git a/src/resources.cpp b/src/resources.cpp index a7a13b8..285e48a 100644 --- a/src/resources.cpp +++ b/src/resources.cpp @@ -35,4 +35,6 @@ namespace callui { const ucl::TString STR_DIALING_CALL {"Dialing"}; const ucl::TString STR_ON_HOLD {"On hold"}; const ucl::TString STR_CALL_ENDED {"Call ended"}; + + const ucl::TString STR_DECLINE_MESSAGES {"Decline messages"}; } -- 2.34.1