*/
virtual IEndCallSRef getEndCall() = 0;
- /**
- * @brief Gets end call instance
- * @return Mask on current available calls
- */
- virtual CallMask getAvailableCalls() const = 0;
-
protected:
~ICallManager() = default;
};
+
+ // Non-member functions //
+
+ /**
+ * @brief Gets call mode by current state of Call Manager
+ * @param[in] cm Call manager instance
+ * @return Current Call mode
+ */
+ CallMode getCallMode(const ICallManagerSRef &cm);
+
+ /**
+ * @brief Gets mask of available calls by current state of Call Manager
+ * @param[in] cm Call manager instance
+ * @return Mask on current available calls
+ */
+ CallMask getAvailableCalls(const ICallManagerSRef &cm);
+
}
#endif // __CALL_UI_MODEL_I_STATE_PROVIDER_H__
return m_endCall;
}
- CallMask CallManager::getAvailableCalls() const
- {
- int res = CALL_FLAG_NONE;
-
- if (m_incomingCall)
- res |= CALL_FLAG_INCOMING;
-
- if (m_activeCall)
- res |= CALL_FLAG_ACTIVE;
-
- if (m_heldCall)
- res |= CALL_FLAG_HELD;
-
- if (m_endCall)
- res |= CALL_FLAG_END;
-
- return res;
- }
-
Result CallManager::dialVoiceCall(const std::string &number)
{
char buff[impl::TEL_NUMBER_MAX_SIZE] = { 0 };
return RES_FAIL;
}
+ // Non-member functions //
+
+ CallMode getCallMode(const ICallManagerSRef &cm)
+ {
+ if (!cm) {
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS,
+ CallMode::UNDEFINED, "cm is NULL");
+ }
+
+ auto incom = cm->getIncomingCall();
+ auto active = cm->getActiveCall();
+ auto held = cm->getHeldCall();
+ auto end = cm->getEndCall();
+
+ if (incom) {
+ return CallMode::INCOMING;
+ } else if (active && active->isDialingMode()) {
+ return CallMode::OUTGOING;
+ } else if (active || held) {
+ return CallMode::DURING;
+ } else if (end) {
+ return CallMode::END;
+ }
+ return CallMode::UNDEFINED;
+ }
+
+ CallMask getAvailableCalls(const ICallManagerSRef &cm)
+ {
+ if (!cm) {
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS,
+ CALL_FLAG_NONE, "cm is NULL");
+ }
+
+ auto incom = cm->getIncomingCall();
+ auto active = cm->getActiveCall();
+ auto held = cm->getHeldCall();
+ auto end = cm->getEndCall();
+
+ int res = CALL_FLAG_NONE;
+
+ if (incom)
+ res |= CALL_FLAG_INCOMING;
+
+ if (active)
+ res |= CALL_FLAG_ACTIVE;
+
+ if (held)
+ res |= CALL_FLAG_HELD;
+
+ if (end)
+ res |= CALL_FLAG_END;
+
+ return res;
+ }
+
}
*/
virtual IEndCallSRef getEndCall() override final;
- /*
- * @see ICallManager::getAvailableCalls()
- */
- virtual CallMask getAvailableCalls() const override final;
-
private:
CallManager(ucl::IRefCountObj &rc, const CallClientSRef &callClient,
ICallManagerListenerWRef listener);
ICallInfoSCRef CallUI::getCurrentCallInfo() const
{
- CallMask calls = m_callManager->getAvailableCalls();
- if (!calls) {
+ CallMask calls = getAvailableCalls(m_callManager);
+ if (calls == CALL_FLAG_NONE) {
DLOG("No available calls");
return {};
} else if (calls & CALL_FLAG_INCOMING) {
HD_VOICE /**< Call HD voice property */
};
+ /**
+ * @brief Enumeration of Call modes
+ */
+ enum class CallMode {
+ UNDEFINED, /**< Undefined */
+ INCOMING, /**< Incoming */
+ OUTGOING, /**< Outgoing */
+ DURING, /**< During */
+ END /**< End */
+ };
+
}
#endif // __CALL_UI_MODEL_TYPES_H__
if (res != RES_OK) {
ELOG("processAppControl() failed!");
ICallManagerSRef callManager = m_call->getCallManager();
- if (!callManager->getAvailableCalls()) {
+ if (getAvailableCalls(callManager) == CALL_FLAG_NONE) {
ILOG("No calls. Exit application");
m_context->exitApp();
}
Eina_Bool Instance::onKeyUpEventCb(int type, void *event)
{
if (!event) {
- LOG_RETURN_VALUE(RES_FAIL, ECORE_CALLBACK_PASS_ON, "event is NULL");
+ LOG_RETURN_VALUE(RES_FAIL, ECORE_CALLBACK_PASS_ON,
+ "event is NULL");
}
Ecore_Event_Key *ev = static_cast<Ecore_Event_Key *>(event);
constexpr EdjeSignal SIGNAL_TURN_ON {"turn.on"};
constexpr EdjeSignal SIGNAL_TURN_OFF {"turn.off"};
+
+ Result launchBluetoothSettings()
+ {
+ AppCtrlAuto appCtrl;
+
+ FAIL_RETURN(util::getNz(app_control_create, appCtrl),
+ "app_control_create() failed!");
+
+ FAIL_RETURN(util::call(app_control_set_app_id,
+ appCtrl, "org.tizen.bluetooth"),
+ "app_control_set_app_id() failed!");
+
+ FAIL_RETURN(util::call(app_control_add_extra_data,
+ appCtrl, "launch-type", "call"),
+ "app_control_add_extra_data() failed!");
+
+ FAIL_RETURN(util::call(app_control_send_launch_request,
+ appCtrl, nullptr, nullptr),
+ "app_control_send_launch_request() failed!");
+
+ return RES_OK;
+ }
+
+ Result launchAddContact(const std::string &telNumber)
+ {
+ AppCtrlAuto appCtrl;
+
+ FAIL_RETURN(util::getNz(app_control_create, appCtrl),
+ "app_control_create() failed!");
+
+ FAIL_RETURN(util::call(app_control_set_operation,
+ appCtrl, APP_CONTROL_OPERATION_ADD),
+ "app_control_set_app_id() failed!");
+
+ FAIL_RETURN(util::call(app_control_set_mime,
+ appCtrl, CU_APP_CONTROL_MIME_CONTACT),
+ "app_control_set_app_id() failed!");
+
+ FAIL_RETURN(util::call(app_control_add_extra_data,
+ appCtrl, APP_CONTROL_DATA_PHONE, telNumber.c_str()),
+ "app_control_add_extra_data() failed!");
+
+ FAIL_RETURN(util::call(app_control_send_launch_request,
+ appCtrl, nullptr, nullptr),
+ "app_control_send_launch_request() failed!");
+
+ return RES_OK;
+ }
}}}
namespace callui {
m_sm(sm),
m_vcTimer(nullptr),
m_audioState(m_sm->getAudioState()),
- m_mode(ComponentsMode::UNDEFINED),
+ m_mode(CallMode::UNDEFINED),
m_exitHandler(handler),
m_isVcShowOnRotaryEvent(false)
{
void AccessoryPresenter::updateMode(const ICallManagerSRef &cm)
{
- m_mode = getCurrentMode(cm);
- }
-
- AccessoryPresenter::ComponentsMode AccessoryPresenter::getCurrentMode(
- const ICallManagerSRef &cm)
- {
- auto active = cm->getActiveCall();
- auto held = cm->getHeldCall();
- auto end = cm->getEndCall();
-
- if (active && active->isDialingMode()) {
- return ComponentsMode::OUTGOING;
- } else if (active || held) {
- return ComponentsMode::DURING;
- } else if (end) {
- return ComponentsMode::END;
- }
- return ComponentsMode::UNDEFINED;
+ m_mode = getCallMode(cm);
}
void AccessoryPresenter::setVolumeSliderVisiblity(bool isVisible)
m_addContactBtn.reset();
m_unsavedPhoneNumber.clear();
- setVolumeSliderVisiblity(m_mode != ComponentsMode::END);
+ setVolumeSliderVisiblity(m_mode != CallMode::END);
switch (m_mode) {
- case ComponentsMode::OUTGOING:
- case ComponentsMode::DURING:
+ case CallMode::OUTGOING:
+ case CallMode::DURING:
return setActiveCallCompomnents();
- case ComponentsMode::END:
+ case CallMode::END:
return setEndCallCompomnents(cm);
default:
return RES_OK;
FAIL_RETURN(createBluetoothBtn(), "createBluetoothBtn() failed");
m_widget->setContent(*m_bluetoothBtn, impl::PART_SWL_SLOT2);
- if (m_mode == ComponentsMode::OUTGOING) {
+ if (m_mode == CallMode::OUTGOING) {
disable(*m_muteBtn);
} else {
enable(*m_muteBtn);
auto res = m_sm->setBluetoothState(true);
if (res == RES_NOT_CONNECTED) {
DLOG("Launch bluetooth settings...");
- FAIL_RETURN_VOID(launchBluetoothSettings(),
+ FAIL_RETURN_VOID(impl::launchBluetoothSettings(),
"launchBluetoothSettings() failed");
} else {
FAIL_RETURN_VOID(res, "setBluetoothState(true) failed");
}
}
- Result AccessoryPresenter::launchBluetoothSettings()
- {
- AppCtrlAuto appCtrl;
-
- FAIL_RETURN(util::getNz(app_control_create, appCtrl),
- "app_control_create() failed!");
-
- FAIL_RETURN(util::call(app_control_set_app_id,
- appCtrl, "org.tizen.bluetooth"),
- "app_control_set_app_id() failed!");
-
- FAIL_RETURN(util::call(app_control_add_extra_data,
- appCtrl, "launch-type", "call"),
- "app_control_add_extra_data() failed!");
-
- FAIL_RETURN(util::call(app_control_send_launch_request,
- appCtrl, nullptr, nullptr),
- "app_control_send_launch_request() failed!");
-
- return RES_OK;
- }
-
- Result AccessoryPresenter::launchContacts()
- {
- AppCtrlAuto appCtrl;
-
- FAIL_RETURN(util::getNz(app_control_create, appCtrl),
- "app_control_create() failed!");
-
- FAIL_RETURN(util::call(app_control_set_operation,
- appCtrl, APP_CONTROL_OPERATION_ADD),
- "app_control_set_app_id() failed!");
-
- FAIL_RETURN(util::call(app_control_set_mime,
- appCtrl, CU_APP_CONTROL_MIME_CONTACT),
- "app_control_set_app_id() failed!");
-
- FAIL_RETURN(util::call(app_control_add_extra_data,
- appCtrl, APP_CONTROL_DATA_PHONE, m_unsavedPhoneNumber.c_str()),
- "app_control_add_extra_data() failed!");
-
- FAIL_RETURN(util::call(app_control_send_launch_request,
- appCtrl, nullptr, nullptr),
- "app_control_send_launch_request() failed!");
-
- return RES_OK;
- }
-
void AccessoryPresenter::onAddContactBtnClicked(Widget &widget, void *eventInfo)
{
- launchContacts();
+ Result res = impl::launchAddContact(m_unsavedPhoneNumber);
+ if (res != RES_OK) {
+ RESLOG(res, "launchAddContact() failed");
+ }
if (m_exitHandler) {
m_exitHandler();
"Ignored. Presenter is not active");
}
- if (m_mode == ComponentsMode::END) {
+ if (m_mode == CallMode::END) {
return RES_OK;
}
*/
ucl::ElmWidget *getVolumeControlValueTxtAo();
- private:
- enum class ComponentsMode {
- UNDEFINED,
- OUTGOING,
- DURING,
- END
- };
private:
AccessoryPresenter(ucl::IRefCountObj &rc, const ISoundManagerSRef &sm,
const NotiHandler &handler);
void onBluetoothBtnClicked(ucl::Widget &widget, void *eventInfo);
void onAddContactBtnClicked(ucl::Widget &widget, void *eventInfo);
- ucl::Result launchContacts();
- ucl::Result launchBluetoothSettings();
-
void registerCallbacks();
void unregisterCallbacks();
void onVolumeControlEventCb(VolumeControl::Event event);
void updateMaxVolume();
void updateMode(const ICallManagerSRef &cm);
- AccessoryPresenter::ComponentsMode getCurrentMode(const ICallManagerSRef &cm);
void setVolumeSliderVisiblity(bool isVisible);
ucl::Result updateModeRelativeComponents(const ICallManagerSRef &cm);
Ecore_Timer *m_vcTimer;
AudioStateType m_audioState;
- ComponentsMode m_mode;
+ CallMode m_mode;
std::string m_unsavedPhoneNumber;
NotiHandler m_exitHandler;
using namespace ucl;
- constexpr int SUB_TXT_WIDTH = 208;
- constexpr int INCOM_MAIN_TXT_WIDTH = 190;
+ constexpr int SUB_TXT_MAX_WIDTH = 208;
constexpr int SLIDE_LABEL_DURATION_KOEFF = 8;
- const char *CU_BIG_FONT_STYLE = "Tizen:style=Condensed";
- constexpr int CU_BIG_FONT_SIZE = 40;
+ const char *INCOMING_CALL_MAIN_TEXT_FONT_STYLE = "Tizen:style=Condensed";
+ constexpr int INCOMING_CALL_MAIN_TEXT_FONT_SIZE = 40;
+ constexpr int INCOMING_CALL_MAIN_TEXT_MAX_WIDTH = 190;
constexpr LayoutTheme LAYOUT_CALLER_INFO_WIDGET
{"layout", "callui", "call_info"};
return size;
}
+ bool isIncomingCallMainTextSingleline(ElmWidget &widget,
+ const std::string &mainText)
+ {
+ return (getTextWidth(widget,
+ INCOMING_CALL_MAIN_TEXT_FONT_STYLE,
+ INCOMING_CALL_MAIN_TEXT_FONT_SIZE,
+ mainText) <= INCOMING_CALL_MAIN_TEXT_MAX_WIDTH);
+ }
+
}}}
namespace callui {
using namespace ucl;
- CallInfoPresenter::Builder::Builder():
- m_mode(CallMode::UNDEFINED)
+ CallInfoPresenter::Builder::Builder()
{
}
return *this;
}
- CallInfoPresenter::Builder &
- CallInfoPresenter::Builder::setMode(CallMode mode)
- {
- m_mode = mode;
- return *this;
- }
-
CallInfoPresenter::Builder &
CallInfoPresenter::Builder::setParentWidget(
const ucl::ElmWidgetSRef &parentWidget)
CallInfoPresenterSRef
CallInfoPresenter::Builder::build(GuiPresenter &parent) const
{
- if (m_mode == CallMode::UNDEFINED || !m_cm || !m_parentWidget) {
+ if (!m_cm || !m_parentWidget) {
LOG_RETURN_VALUE(RES_FAIL, {}, "Main params are are set");
}
- auto result = makeShared<CallInfoPresenter>(m_cm, m_mode);
+ auto result = makeShared<CallInfoPresenter>(m_cm);
FAIL_RETURN_VALUE(result->prepare(parent, *m_parentWidget), {},
"result->prepare() failed!");
}
CallInfoPresenter::CallInfoPresenter(IRefCountObj &rc,
- const ICallManagerSRef &cm,
- CallMode mode):
+ const ICallManagerSRef &cm):
GuiPresenter(rc),
- m_mode(mode),
+ m_mode(getCallMode(cm)),
m_isSubTxtEnable(false),
m_needModifyCallStatus(false)
{
void CallInfoPresenter::initCallInfos(const ICallManagerSRef &cm)
{
+ m_incomCallInfo.reset();
+ m_activeCallInfo.reset();
+ m_heldCallInfo.reset();
+ m_endCallInfo.reset();
+
auto incom = cm->getIncomingCall();
if (incom) {
m_incomCallInfo = incom->getInfo();
- } else {
- m_incomCallInfo.reset();
}
auto active = cm->getActiveCall();
if (active) {
m_activeCallInfo = active->getInfo();
- } else {
- m_activeCallInfo.reset();
}
auto held = cm->getHeldCall();
if (held) {
m_heldCallInfo = held->getInfo();
- } else {
- m_heldCallInfo.reset();
}
auto end = cm->getEndCall();
if (end) {
m_endCallInfo = end->getInfo();
- } else {
- m_endCallInfo.reset();
}
}
- Result CallInfoPresenter::update(CallMode mode, const ICallManagerSRef &cm)
+ Result CallInfoPresenter::update(const ICallManagerSRef &cm)
{
m_needModifyCallStatus = false;
+ CallMode mode = getCallMode(cm);
if (mode != m_mode || mode == CallMode::DURING) {
m_needModifyCallStatus = true;
}
m_label->setStyle(impl::STYLE_SLIDING_LABEL);
m_label->setText(txtStyle.format(text.c_str()));
- elm_label_slide_mode_set(*m_label,ELM_LABEL_SLIDE_MODE_AUTO);
- elm_label_wrap_width_set(*m_label,ELM_SCALE_SIZE(impl::SUB_TXT_WIDTH));
+ elm_label_slide_mode_set(*m_label, ELM_LABEL_SLIDE_MODE_AUTO);
+ elm_label_wrap_width_set(*m_label,
+ ELM_SCALE_SIZE(impl::SUB_TXT_MAX_WIDTH));
double duration = (static_cast<double>(text.size())) /
impl::SLIDE_LABEL_DURATION_KOEFF;
Result CallInfoPresenter::updateCallerId()
{
m_callerId.reset();
- m_widget->emit(impl::SIGN_CID_DISABLE,impl::SRC_CALLER_ID);
+ m_widget->emit(impl::SIGN_CID_DISABLE, impl::SRC_CALLER_ID);
if (m_mode == CallMode::INCOMING) {
m_widget->emit(impl::SIGN_CID_DISABLE, impl::SRC_TXT_1LINE);
}
// Info text top padding
- if (impl::getTextWidth(*m_widget,
- impl::CU_BIG_FONT_STYLE,
- impl::CU_BIG_FONT_SIZE,
- text) <= impl::INCOM_MAIN_TXT_WIDTH) {
+ if (impl::isIncomingCallMainTextSingleline(*m_widget, text)) {
m_widget->emit(impl::SIGN_CENTRE_1LINE, impl::SRC_TOP_PAD);
} else {
m_widget->emit(impl::SIGN_CENTRE_2LINE, impl::SRC_TOP_PAD);
*m_widget,
impl::PART_AO_SUB_TXT);
if (!m_subTxtAO) {
- LOG_RETURN(RES_FAIL, "createAccessObjectFromLyPart() failed!");
+ LOG_RETURN(RES_FAIL,
+ "createAccessObjectFromLyPart() failed!");
}
}
*/
Builder &setCallManager(const ICallManagerSRef &cm);
- /**
- * @brief Sets Call mode
- * @param[in] mode Call mode
- * @return Reference to builder
- */
- Builder &setMode(CallMode mode);
-
/**
* @brief Sets parent widget for UI components creation
* @param[in] parentWidget Parent widget
* on success or NULL otherwise
*/
CallInfoPresenterSRef build(ucl::GuiPresenter &parent) const;
+
private:
ICallManagerSRef m_cm;
- CallMode m_mode;
ucl::ElmWidgetSRef m_parentWidget;
};
ucl::Widget &getWidget();
/**
- * @brief Update presenter
- * @param[in] mode Call mode
+ * @brief Updates presenter
* @param[in] cm Call Manager instance
* @return RES_OK on success or another result otherwise
*/
- ucl::Result update(CallMode mode, const ICallManagerSRef &cm);
+ ucl::Result update(const ICallManagerSRef &cm);
/**
* @brief Gets Access object for status text area
private:
CallInfoPresenter(ucl::IRefCountObj &rc,
- const ICallManagerSRef &cm,
- CallMode mode);
+ const ICallManagerSRef &cm);
~CallInfoPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent,
ucl::StyledWidgetSRef m_label;
ucl::GuiPresenterWRef m_parent;
CallMode m_mode;
+
ICallInfoSCRef m_incomCallInfo;
ICallInfoSCRef m_activeCallInfo;
ICallInfoSCRef m_heldCallInfo;
#include "call-ui/model/types.h"
-namespace callui {
-
- /**
- * @brief Enumeration of Call modes
- */
- enum class CallMode {
- UNDEFINED, /**< Undefined */
- INCOMING, /**< Incoming */
- OUTGOING, /**< Outgoing */
- DURING, /**< During */
- END /**< End */
- };
-}
-
#endif // __CALL_UI_PRESENTERS_MISC_TYPES_H__
return RES_OK;
}
- void MainPage::updateCallMode()
- {
- auto incom = m_cm->getIncomingCall();
- auto active = m_cm->getActiveCall();
- auto held = m_cm->getHeldCall();
- auto end = m_cm->getEndCall();
-
- m_mode = CallMode::UNDEFINED;
-
- if (incom) {
- DLOG("Mode [Incoming call]");
- m_mode = CallMode::INCOMING;
- } else if (active && active->isDialingMode()) {
- DLOG("Mode [Outgoing call]");
- m_mode = CallMode::OUTGOING;
- } else if (active || held) {
- DLOG("Mode [During call]");
- m_mode = CallMode::DURING;
- } else if (end) {
- DLOG("Mode [End call]");
- m_mode = CallMode::END;
- } else {
- DLOG("Mode [Undefined]");
- }
- }
-
Result MainPage::showWindow()
{
auto win = getNaviframe().getWindow();
}
if (!win->isVisible() &&
- (m_mode == CallMode::INCOMING
- || m_mode == CallMode::OUTGOING)) {
+ (m_mode == CallMode::INCOMING ||
+ m_mode == CallMode::OUTGOING)) {
show(*win);
}
return RES_OK;
Result MainPage::createBottomBtn(const ElmStyle &style, bool setVisible)
{
- m_bottomBtn = makeShared<StyledWidget>(
- elm_button_add(*m_widget));
+ m_bottomBtn = makeShared<StyledWidget>(elm_button_add(*m_widget));
m_bottomBtn->setStyle(style);
m_bottomBtn->addEventHandler(BTN_CLICKED,
stopEndCallTimer();
CallMode prevMode = m_mode;
- updateCallMode();
+ m_mode = getCallMode(m_cm);
if (m_mode == CallMode::UNDEFINED) {
requestExit();
break;
}
- FAIL_RETURN_VOID(createCallInfoPresenter(m_mode),
+ FAIL_RETURN_VOID(createCallInfoPresenter(),
"createCallInfoPresenter() failed!");
FAIL_RETURN_VOID(updateDeviceState(prevMode, m_mode),
Result MainPage::createAcceptRejectPresenter()
{
if (m_acceptRejectPrs) {
- m_acceptRejectPrs->update(m_cm->getAvailableCalls());
+ m_acceptRejectPrs->update(getAvailableCalls(m_cm));
return RES_OK;
}
m_acceptRejectPrs = AcceptRejectPresenter::Builder().
setIncomingCall(m_cm->getIncomingCall()).
- setAvailableCallsFlag(m_cm->getAvailableCalls()).
+ setAvailableCallsFlag(getAvailableCalls(m_cm)).
setSoundManager(m_call->getSoundManager()).
setParentWidget(m_widget).
build(*this);
return RES_OK;
}
- Result MainPage::createCallInfoPresenter(CallMode mode)
+ Result MainPage::createCallInfoPresenter()
{
if (m_callInfoPrs) {
- return m_callInfoPrs->update(mode, m_cm);
+ return m_callInfoPrs->update(m_cm);
}
m_callInfoPrs = CallInfoPresenter::Builder().
setCallManager(m_cm).
- setMode(mode).
setParentWidget(m_widget).
build(*this);
void MainPage::onError(CallErr err)
{
- if (!m_cm->getAvailableCalls()) {
+ if (getAvailableCalls(m_cm) == CALL_FLAG_NONE) {
requestExit();
}
}
void processKeyPress(bool isPowerKey = false);
ucl::Result showWindow();
- void updateCallMode();
ucl::Result processIncomingCallMode();
ucl::Result processEndCallMode();
ucl::Result processRegularCallModes();
- ucl::Result createCallInfoPresenter(CallMode mode);
+ ucl::Result createCallInfoPresenter();
ucl::Result createAccessoryPresenter();
ucl::Result createMoreOptionsPresenter();
ucl::Result createAcceptRejectPresenter();
projects / profile / wearable / apps / native / call-ui.git / commitdiff