color_class { name: "AO0311D";
color: 255 255 255 77;
}
+ color_class { name: "AO029";
+ color: 255 255 255 204;
+ }
}
desc { "default";
}
}
+ swallow { "swl.rm"
+ scale;
+ desc { "default";
+ }
+ }
swallow { "swl.accept_reject";
scale;
desc { "default";
}
}
+ swallow { "swl.overlay";
+ scale;
+ desc { "default";
+ }
+ }
}
}
}
}
}
-}
\ No newline at end of file
+}
--- /dev/null
+/*
+ * 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;
+ }
+ }
+ }
+}
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__
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;
#ifndef __CALLUI_PRESENTERS_CALL_STATUS_H__
#define __CALLUI_PRESENTERS_CALL_STATUS_H__
+#include "Presenter.h"
+
#include <time.h>
#include "ucl/gui/Layout.h"
namespace callui {
- class CallStatus final : public ucl::RefCountAware {
+ class CallStatus final : public Presenter {
public:
class Builder {
public:
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;
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;
};
}
return (m_navi->getBottomItem() == m_item);
}
- // Non-member functions //
+ // Non-member functions
inline bool isLast(const Page &page)
{
--- /dev/null
+/*
+ * 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>;
+ 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__
END
};
+ enum class RejectMsgState {
+ HIDDEN,
+ IN_TRANSITION,
+ SHOWN
+ };
+
UCL_DECLARE_REF_ALIASES(Page);
UCL_DECLARE_REF_ALIASES(MainPage);
UCL_DECLARE_REF_ALIASES(CallInfoPresenter);
UCL_DECLARE_REF_ALIASES(CallStatus);
+ UCL_DECLARE_REF_ALIASES(RejectMsgPresenter);
+
using AcceptDialogHandler = ucl::WeakDelegate<bool(AcceptDialog &, AcceptDialogEvent)>;
+ using RejectMsgStateHandler = ucl::WeakDelegate<void(RejectMsgState)>;
+ using RejectMsgSelectHandler = ucl::WeakDelegate<void(const IRejectMsgSRef &rm)>;
}
#endif // __CALLUI_PRESENTERS_TYPES_H__
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__
#include "../../edc/indicator.edc"
#include "../../edc/call_info.edc"
+ #include "../../edc/reject_msg.edc"
}
return m_confMemberList;
}
+ // Non-member functions
+
+ bool isUnknownCaller(const ICallInfo &info)
+ {
+ auto contactInfo = info.getContactInfo();
+ return (info.getPhoneNumber().empty() &&
+ (!contactInfo || contactInfo->getName().empty()));
+ }
+
}
constexpr SmartEvent POPUP_DISMISSED {"dismissed"};
+ constexpr EdjePart PART_SWL_CONTENT{"elm.swallow.content"};
+
void *asData(const AcceptDialogEvent event)
{
return reinterpret_cast<void *>(static_cast<intptr_t>(event));
m_rc->ref();
+ addDeactivatorException(this);
+ broadcastDeactivateBy(this);
+
return RES_OK;
}
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<Elm_Object_Item *>(event_info);
+ Elm_Object_Item *item = static_cast<Elm_Object_Item *>(eventInfo);
handleEvent(impl::asEvent(elm_object_item_data_get(item)));
}
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;
}
{
if (m_popup && !m_isDismissed) {
m_isDismissed = true;
+ deactivateBy(m_popup.get());
elm_popup_dismiss(*m_popup);
}
}
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();
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);
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);
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!");
if (confMemberCount > 1) {
return TString{STR_WITH_PD_PEOPLE.translate()}.format(confMemberCount);
}
+ } else {
+ ELOG("Invalid call data");
}
- ELOG("Invalid call data");
return "";
}
CallInfoMode mode,
const ICallInfoWCRef &info,
bool isHeld):
- RefCountAware(&rc),
+ Presenter(rc),
m_ly(layout),
m_mode(mode),
m_info(info),
#include "ucl/gui/Window.h"
#include "ucl/gui/Layout.h"
+#include "ucl/gui/Widget.h"
#include "model/ICall.h"
#include "model/ICallManager.h"
#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 {
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 {
});
}
+ 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();
}
}
+ 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<int>(type));
}
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;
{
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();
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);
--- /dev/null
+/*
+ * 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, "<br/>", " ");
+ 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<RejectMsgPresenter>(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<Elm_Panel_Scroll_Info *>(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<StyledWidget>(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<ElmWidget>(
+ 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<StyledWidget>(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<RejectMsgItem *>(data);
+ return strdup(rm->getDisplayText().c_str());
+ },
+ nullptr,
+ nullptr,
+ [](void *data, Evas_Object *obj) -> void {
+ RejectMsgItem *rm = static_cast<RejectMsgItem *>(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<void *>(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<Elm_Object_Item *>(eventInfo);
+ auto *rmItem = static_cast<RejectMsgItem *>(
+ 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);
+ }
+
+}
--- /dev/null
+/*
+ * 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();
+ }
+ }
+
+}
--- /dev/null
+/*
+ * 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 <string>
+
+namespace callui {
+
+ void replaceSubstringInString(std::string &str,
+ const std::string &from, const std::string &to);
+}
+
+#endif // __CALLUI_PRESENTERS_HELPERS_H__
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"};
}
projects / profile / wearable / apps / native / call-ui.git / commitdiff
