</tool>
</toolChain>
</folderInfo>
- <fileInfo id="org.tizen.nativecore.config.sbi.gcc45.app.debug.746875570.28367371" name="SlidingLabel.cpp" rcbsApplicability="disable" resourcePath="src/view/SlidingLabel.cpp" toolsToInvoke="org.tizen.nativecore.tool.sbi.gnu.cpp.compiler.66050065.777132781">
- <tool id="org.tizen.nativecore.tool.sbi.gnu.cpp.compiler.66050065.777132781" name="C++ Compiler" superClass="org.tizen.nativecore.tool.sbi.gnu.cpp.compiler.66050065"/>
- </fileInfo>
- <fileInfo id="org.tizen.nativecore.config.sbi.gcc45.app.debug.746875570.972811223" name="SlidingLabel.h" rcbsApplicability="disable" resourcePath="inc/view/SlidingLabel.h" toolsToInvoke=""/>
<sourceEntries>
<entry excluding="view/SlidingLabel.h" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="inc"/>
<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="res"/>
* limitations under the License.
*/
-#define CU_BTN_ANIM_TIME 0.15
-#define CU_BTN_UNPRESS_DELAY 0.6
+#define CU_BTN_INCOM_CALL_ANIM_TIME 0.15
+#define CU_BTN_INCOM_CALL_UNPRESS_DELAY 0.6
+#define CU_BTN_INCOM_CALL_ICON_SIZE 54 54
+#define CU_BTN_INCOM_CALL_EFF_START_SIZE 100 100
+#define CU_BTN_INCOM_CALL_EFF_END_DIMENTION 130
+#define CU_BTN_INCOM_CALL_EFF_END_SIZE CU_BTN_INCOM_CALL_EFF_END_DIMENTION CU_BTN_INCOM_CALL_EFF_END_DIMENTION
-#define CU_BTN_ICON_WH 54
-#define CU_BTN_EFFECT_START_WH 100
-#define CU_BTN_EFFECT_END_WH 130
+#define CU_BTN_BOTTOM_ICON_TOP_PADDING_INC 14
+#define CU_BTN_BOTTOM_SIZE_INC 360 78
+#define CU_BTN_BOTTOM_ICON_SIZE_INC 50 50
-#define INCOMING_CALL_BTN(_name, _icon, _bg_cc, _effect_cc, _icon_norm_cc, _icon_pressed_cc) \
+#define CU_BTN_INCOM_CALL(_name, _icon, _bg_cc, _effect_cc, _icon_norm_cc, _icon_pressed_cc) \
group { "elm/button/base/"_name; \
script { \
public is_pressed; \
emit("elm,action,press", ""); \
} \
if (auto_unpress) { \
- set_int(unpress_timer, timer(CU_BTN_UNPRESS_DELAY, "unpress", 0)); \
+ set_int(unpress_timer, timer(CU_BTN_INCOM_CALL_UNPRESS_DELAY, "unpress", 0)); \
} \
} \
public unpress() \
if (get_int(is_pressed) == 1 && get_int(is_expanded) == 0) { \
set_int(is_expanded, 1); \
run_program(PROGRAM:"expanded"); \
- timer(CU_BTN_ANIM_TIME + 0.1, "click", 0); \
+ timer(CU_BTN_INCOM_CALL_ANIM_TIME + 0.1, "click", 0); \
} \
} \
public click() \
} \
desc { "pressed_effect"; \
inherit: "default"; \
- min: CU_BTN_EFFECT_START_WH CU_BTN_EFFECT_START_WH; \
+ min: CU_BTN_INCOM_CALL_EFF_START_SIZE; \
} \
desc { "pressed"; \
inherit: "pressed_effect"; \
- min: CU_BTN_EFFECT_END_WH CU_BTN_EFFECT_END_WH; \
+ min: CU_BTN_INCOM_CALL_EFF_END_SIZE; \
} \
desc { "expanded"; \
inherit: "pressed"; \
clip: "rect.icon_bg"; \
desc { "default"; \
fixed: 1 1; \
- min: CU_BTN_ICON_WH CU_BTN_ICON_WH; \
+ min: CU_BTN_INCOM_CALL_ICON_SIZE; \
rel1.relative: 0.5 0.5; \
rel2.relative: 0.5 0.5; \
image.normal: _icon; \
rect { "rect.event"; \
desc { "default"; \
fixed: 1 1; \
- min: CU_BTN_EFFECT_START_WH CU_BTN_EFFECT_START_WH; \
+ min: CU_BTN_INCOM_CALL_EFF_START_SIZE; \
rel1.relative: 0.5 0.5; \
rel2.relative: 0.5 0.5; \
color: 0 0 0 0; \
targets: "image.effect" "image.border"; \
action: STATE_SET "pressed"; \
targets: "image.effect" "image.border" "rect.icon_bg"; \
- transition: TRANSITION_GLIDE(CU_BTN_ANIM_TIME); \
+ transition: TRANSITION_GLIDE(CU_BTN_INCOM_CALL_ANIM_TIME); \
} \
} \
program { \
targets: "image.border" "rect.icon_bg"; \
action: STATE_SET "pressed_effect"; \
target: "image.effect"; \
- transition: TRANSITION_GLIDE(CU_BTN_ANIM_TIME); \
+ transition: TRANSITION_GLIDE(CU_BTN_INCOM_CALL_ANIM_TIME); \
action: STATE_SET "default"; \
target: "image.effect"; \
} \
name: "expanded"; \
action: STATE_SET "expanded"; \
target: "image.border"; \
- transition: TRANSITION_GLIDE(CU_BTN_ANIM_TIME); \
+ transition: TRANSITION_GLIDE(CU_BTN_INCOM_CALL_ANIM_TIME); \
} \
program { \
signal: "mouse,move"; \
get_geometry(PART:"image.effect", x, y, w, h); \
if (d >= w) { \
expand(); \
- } else if (d <= CU_BTN_EFFECT_END_WH) { \
+ } else if (d <= CU_BTN_INCOM_CALL_EFF_END_DIMENTION) { \
set_state(PART:"image.border", "pressed", 0.0); \
} else { \
new Float:rel = ((w - d) / w) / 2; \
} \
}
-INCOMING_CALL_BTN("callui/accept", "w_call_incoming_icon_accept.png", "AO01131", "AO01132", "AO0113", "AO0113P")
-INCOMING_CALL_BTN("callui/reject", "w_call_incoming_icon_reject.png", "AO01151", "AO01152", "AO0115", "AO0115P")
+#define CU_BTN_BOTTOM(_name, _icon, _normal_cc, _pressed_cc, _overlay_normal_cc, _overlay_pressed_cc) \
+ group { "elm/button/base/"_name; \
+ images { \
+ image: "tw_bottom_btn_bg.png" COMP; \
+ image: _icon COMP; \
+ } \
+ parts { \
+ spacer { "base"; \
+ scale; \
+ desc { "default"; \
+ min: CU_BTN_BOTTOM_SIZE_INC; \
+ } \
+ } \
+ image { "elm.content.bg"; \
+ scale; \
+ nomouse; \
+ repeat; \
+ desc { "default"; \
+ image.normal: "tw_bottom_btn_bg.png"; \
+ color_class: _normal_cc; \
+ rel.to: "base"; \
+ } \
+ desc { "pressed"; \
+ inherit: "default"; \
+ color_class: _pressed_cc; \
+ } \
+ desc { "disabled"; \
+ inherit: "default"; \
+ color_class: DISABLED_BTN; \
+ } \
+ } \
+ image { "elm.content.bg.overlay"; \
+ scale; \
+ nomouse; \
+ desc { "default"; \
+ image.normal: "tw_bottom_btn_bg.png"; \
+ rel.to: "elm.content.bg"; \
+ color_class: _overlay_normal_cc; \
+ } \
+ desc { "pressed"; \
+ inherit: "default"; \
+ color_class: _overlay_pressed_cc; \
+ } \
+ } \
+ spacer { "icon_padding_top"; \
+ scale; \
+ desc { "default"; \
+ fixed: 0 1; \
+ min: 0 CU_BTN_BOTTOM_ICON_TOP_PADDING_INC; \
+ max: -1 CU_BTN_BOTTOM_ICON_TOP_PADDING_INC; \
+ rel1.to: "elm.content.bg"; \
+ rel2.to: "elm.content.bg"; \
+ rel2.relative: 1.0 0.0; \
+ align: 0.5 0.0; \
+ } \
+ } \
+ image { "icon"; \
+ clip: "icon.clipper"; \
+ scale; \
+ desc { "default"; \
+ align: 0.5 0.0; \
+ rel1 { \
+ relative: 0.0 1.0; \
+ to: "icon_padding_top"; \
+ } \
+ rel2 { \
+ relative: 1.0 1.0; \
+ to: "icon_padding_top"; \
+ } \
+ min: CU_BTN_BOTTOM_ICON_SIZE_INC; \
+ max: CU_BTN_BOTTOM_ICON_SIZE_INC; \
+ fixed: 1 1; \
+ image.normal: _icon; \
+ } \
+ } \
+ rect { "icon.clipper"; \
+ scale; \
+ desc { "default"; \
+ rel.to: "icon"; \
+ color: 250 250 250 255; \
+ } \
+ desc { "pressed"; \
+ inherit: "default"; \
+ color: 250 250 250 255; \
+ } \
+ desc { "disabled"; \
+ inherit: "default"; \
+ color: 250 250 250 89; \
+ } \
+ } \
+ image { "event"; \
+ scale; \
+ precise; \
+ desc { "default"; \
+ image.normal: "tw_bottom_btn_bg.png"; \
+ color: 0 0 0 0; \
+ rel.to: "elm.content.bg"; \
+ } \
+ } \
+ } \
+ programs { \
+ script { \
+ public mouse_down = 0; \
+ public multi_down = 0; \
+ public disabled = 0; \
+ } \
+ program { "pressed"; \
+ signal: "mouse,down,1*"; \
+ source: "event"; \
+ action: SIGNAL_EMIT "elm,action,press" ""; \
+ after: "on_pressed"; \
+ } \
+ program { "unpressed"; \
+ signal: "mouse,up,1*"; \
+ source: "event"; \
+ action: SIGNAL_EMIT "elm,action,unpress" ""; \
+ after: "on_unpressed"; \
+ } \
+ program { "clicked"; \
+ signal: "mouse,clicked,1"; \
+ source: "event"; \
+ action: SIGNAL_EMIT "elm,action,click" ""; \
+ after: "on_clicked"; \
+ } \
+ program { "enabled"; \
+ signal: "elm,state,enabled"; \
+ source: "elm"; \
+ action: STATE_SET "default"; \
+ target: "event"; \
+ after: "on_enabled"; \
+ } \
+ program { "disabled"; \
+ signal: "elm,state,disabled"; \
+ source: "elm"; \
+ action: STATE_SET "disabled"; \
+ target: "event"; \
+ after: "on_disabled"; \
+ } \
+ program { "enable_event_pass"; \
+ signal: "elm,event,pass,enabled"; \
+ source: "elm"; \
+ script { \
+ set_mouse_events(PART:"event", 0); \
+ } \
+ } \
+ program { "disable_event_pass"; \
+ signal: "elm,event,pass,disabled"; \
+ source:"elm"; \
+ script { \
+ set_mouse_events(PART:"event", 1); \
+ } \
+ } \
+ program { "enable_event_repeat"; \
+ signal: "elm,event,repeat,enabled"; \
+ source: "elm"; \
+ script { \
+ set_repeat_events(PART:"event", 1); \
+ } \
+ } \
+ program { "disable_event_repeat"; \
+ signal: "elm,event,repeat,disabled"; \
+ source:"elm"; \
+ script { \
+ set_repeat_events(PART:"event", 0); \
+ } \
+ } \
+ program { "on_pressed"; \
+ script { \
+ if ((get_int(multi_down) == 0) && (get_int(mouse_down) == 0)) { \
+ set_int(mouse_down, 1); \
+ if (!get_int(disabled)) { \
+ run_program(PROGRAM:"cancel_effect"); \
+ set_state(PART:"elm.content.bg", "pressed", 0.0); \
+ set_state(PART:"elm.content.bg.overlay", "pressed", 0.0); \
+ set_state(PART:"icon.clipper", "pressed", 0.0); \
+ } \
+ } \
+ } \
+ } \
+ program { "cancel_effect"; \
+ action: ACTION_STOP; \
+ target: "unpressed_effect"; \
+ } \
+ program { "on_unpressed"; \
+ script { \
+ if (get_int(mouse_down) == 1) { \
+ set_int(mouse_down, 0); \
+ if (!get_int(disabled)) { \
+ run_program(PROGRAM:"unpressed_effect"); \
+ } \
+ } \
+ } \
+ } \
+ program { "unpressed_effect"; \
+ in: 0.1 0.0; \
+ action: STATE_SET "default"; \
+ transition: LINEAR 0.2; \
+ target: "elm.content.bg"; \
+ target: "elm.content.bg.overlay"; \
+ target: "icon.clipper"; \
+ } \
+ program { "on_clicked"; \
+ script { \
+ if (get_int(multi_down) == 0) { \
+ if (!get_int(disabled)) { \
+ run_program(PROGRAM:"play_sample"); \
+ } \
+ } \
+ } \
+ } \
+ program { "play_sample"; \
+ action: RUN_PLUGIN "touch_sound"; \
+ } \
+ program { "on_disabled"; \
+ script { \
+ set_int(disabled, 1); \
+ run_program(PROGRAM:"cancel_effect"); \
+ set_state(PART:"elm.content.bg", "disabled", 0.0); \
+ set_state(PART:"elm.content.bg.overlay", "default", 0.0); \
+ set_state(PART:"icon.clipper", "disabled", 0.0); \
+ } \
+ } \
+ program { "on_enabled"; \
+ script { \
+ set_int(disabled, 0); \
+ set_state(PART:"elm.content.bg", "default", 0.0); \
+ set_state(PART:"icon.clipper", "default", 0.0); \
+ } \
+ } \
+ program { "multi_down"; \
+ signal: "elm,action,multi,down"; \
+ source: "elm"; \
+ script { \
+ set_int(multi_down, 1); \
+ } \
+ } \
+ program { "multi_up"; \
+ signal: "elm,action,multi,up"; \
+ source: "elm"; \
+ script { \
+ set_int(multi_down, 0); \
+ } \
+ } \
+ } \
+ }
+
+CU_BTN_INCOM_CALL("callui/accept", "w_call_incoming_icon_accept.png", "AO01131", "AO01132", "AO0113", "AO0113P")
+CU_BTN_INCOM_CALL("callui/reject", "w_call_incoming_icon_reject.png", "AO01151", "AO01152", "AO0115", "AO0115P")
+
+CU_BTN_BOTTOM("callui/end_call", "w_incoming_icon_end_phone.png", "AO0121", "AO0121P", "B013A", "B013")
+CU_BTN_BOTTOM("callui/call_back", "w_incoming_icon_call.png", "AO0171", "AO0171P", "B013A", "B013")
inherit: "default";
min: 0 95;
}
- desc { "2line_1text";
+ desc { "1line_2text";
inherit: "default";
min: 0 99;
}
}
desc { "1line";
inherit: "default";
- min: 208 52;
- max: 208 52;
+ min: 208 53;
+ max: 208 53;
}
desc { "incom_2line";
inherit: "default";
signal: "1line_2text";
source: "top_padding";
script {
- set_state(PART:"top.pad", "default", 0.0);
+ set_state(PART:"top.pad", "1line_2text", 0.0);
set_state(PART:"zone.text_1line", "1line", 0.0);
set_state(PART:"text_1line", "default", 0.0);
}
color_class { name: "AO029";
color: 255 255 255 204;
}
+
+ // Bottom button
+ color_class { name: "DISABLED_BTN";
+ color: 97 97 97 230;
+ }
+ color_class { name: "AO0121";
+ color: 222 11 0 179;
+ }
+ color_class { name: "AO0121P";
+ color: 222 11 0 77;
+ }
+ color_class { name: "AO0171";
+ color: 76 186 39 179;
+ }
+ color_class { name: "AO0171P";
+ color: 76 186 39 77;
+ }
+ color_class { name: "B013A";
+ color: 0 146 204 0;
+ }
+ color_class { name: "B013";
+ color: 0 146 204 77;
+ }
}
desc { "default";
}
}
+ swallow { "swl.bottom_btn";
+ scale;
+ desc { "default";
+ rel1.relative: 0.0 1.0;
+ rel2.relative: 1.0 1.0;
+ align: 0.5 1.0;
+ fixed: 0 1;
+ }
+ }
swallow { "swl.overlay";
scale;
desc { "default";
};
enum {
+ CALL_FLAG_NONE = 0,
CALL_FLAG_INCOMING = 1,
CALL_FLAG_ACTIVE = 2,
CALL_FLAG_HELD = 4,
Builder();
virtual ~Builder();
Builder &setCallManager(const ICallManagerSRef &cm);
- Builder &setMode(CallInfoMode mode);
+ Builder &setMode(CallMode mode);
CallInfoPresenterSRef build(ucl::ElmWidget &parent) const;
private:
ICallManagerSRef m_cm;
- CallInfoMode m_mode;
+ CallMode m_mode;
};
public:
virtual ~CallInfoPresenter();
ucl::Widget &getWidget();
- CallInfoMode getMode() const;
- ucl::Result update(CallInfoMode mode, const ICallManagerSRef &cm);
+ CallMode getMode() const;
+ ucl::Result update(CallMode mode, const ICallManagerSRef &cm);
private:
friend class ucl::RefCountObj<CallInfoPresenter>;
CallInfoPresenter(ucl::RefCountObjBase &rc,
const ICallManagerSRef &cm,
- CallInfoMode mode);
+ CallMode mode);
ucl::Result prepare(ucl::ElmWidget &parent);
ucl::LayoutSRef m_widget;
ucl::StyledWidgetSRef m_callerId;
ucl::StyledWidgetSRef m_label;
- CallInfoMode m_mode;
+ CallMode m_mode;
ICallInfoSCRef m_incomCallInfo;
ICallInfoSCRef m_activeCallInfo;
ICallInfoSCRef m_heldCallInfo;
public:
Builder();
virtual ~Builder();
- Builder &setMode(CallInfoMode mode);
+ Builder &setMode(CallMode mode);
Builder &setCallInfo(const ICallInfoWCRef &info);
Builder &setCallHoldState(bool isOnHold);
Builder &setLayout(const ucl::LayoutSRef &layout);
CallStatusSRef build() const;
private:
ucl::LayoutSRef m_ly;
- CallInfoMode m_mode;
+ CallMode m_mode;
ICallInfoWCRef m_info;
bool m_isOnHold;
};
friend class ucl::RefCountObj<CallStatus>;
CallStatus(ucl::RefCountObjBase &rc,
const ucl::LayoutSRef &layout,
- CallInfoMode mode,
+ CallMode mode,
const ICallInfoWCRef &info,
bool isOnHold);
private:
ucl::LayoutSRef m_ly;
- CallInfoMode m_mode;
+ CallMode m_mode;
ICallInfoWCRef m_info;
bool m_isOnHold;
Ecore_Timer *m_timer;
#include "model/ICallListener.h"
#include "ucl/gui/Layout.h"
-
+#include "ucl/gui/StyledWidget.h"
#include "types.h"
namespace callui {
ucl::Result prepare();
- ucl::Result processIncomingCall(const IIncomingCallSRef &incom);
+ ucl::Result showWindow();
+ void updateCallMode();
+ ucl::Result processIncomingCall();
ucl::Result createAcceptRejectPresenter();
- ucl::Result createRejectMsgPresenter(const IIncomingCallSRef &incom);
- ucl::Result createCallInfoPresenter(CallInfoMode mode);
-
+ ucl::Result createRejectMsgPresenter(const IRejectMsgProviderSRef &provider);
void RejectMsgStateCb(RejectMsgState state);
void RejectMsgSelectCb(const IRejectMsgSRef &rm);
+ ucl::Result createCallInfoPresenter(CallMode mode);
+
+ ucl::Result createBottomBtn(const ucl::ElmStyle &style);
+ void onBottomBtnClicked(ucl::Widget &widget, void *eventInfo);
+
+ void startEndCallTimer();
+ void stopEndCallTimer();
+ Eina_Bool onEndCallTimerCb();
+
// Presenter
virtual void onActivateBy(const DeactivatorInfo &info) final override;
private:
ucl::LayoutSRef m_widget;
ucl::LayoutSRef m_rmLy;
+ ucl::StyledWidgetSRef m_bottomBtn;
ICallSRef m_call;
+ ICallManagerSRef m_cm;
IndicatorSRef m_indicator;
CallInfoPresenterSRef m_callInfoPrs;
AcceptRejectPresenterSRef m_acceptRejectPrs;
RejectMsgPresenterSRef m_rmPrs;
+ CallMode m_mode;
+ Ecore_Timer *m_ecTimer;
+ bool m_ecTimerBtnReq;
};
}
BACK
};
- enum class CallInfoMode {
+ enum class CallMode {
UNDEFINED,
INCOMING,
OUTGOING,
if (!m_cm) {
LOG_RETURN(RES_FAIL, "Call Manager is NULL");
}
+
+ if (m_isDialing) {
+ return m_cm->endCall(m_callInfo->getCallId(),
+ CallReleaseType::BY_CALL_HANDLE);
+ }
return m_cm->endCall(0, CallReleaseType::ALL_ACTIVE);
}
{
if (time == 0) {
ILOG("Call start time does not set");
+ tmTime = {0};
+ return RES_OK;
}
long currTime = 0;
m_callClient(callClient),
m_listener(listener),
m_slot(SimSlot::UNDEFINED),
- m_waitDialing(false)
+ m_waitDialing(false),
+ m_confTypeCallReq(CALL_FLAG_NONE),
+ m_blockCMEvents(false)
{
}
CallMask CallManager::getAvailableCalls() const
{
- int res = 0;
+ int res = CALL_FLAG_NONE;
if (m_incomingCall)
res |= CALL_FLAG_INCOMING;
Result CallManager::endCall(unsigned int callId, CallReleaseType type)
{
+ ICallInfoSCRef info;
+ int flag = CALL_FLAG_NONE;
+ if (type == CallReleaseType::ALL_ACTIVE
+ && !m_incomingCall
+ && !m_heldCall) {
+ info = m_activeCall->getInfo();
+ flag = CALL_FLAG_ACTIVE;
+ } else if (type == CallReleaseType::ALL_HOLD
+ && !m_incomingCall
+ && !m_activeCall) {
+ info = m_heldCall->getInfo();
+ flag = CALL_FLAG_HELD;
+ }
+
+ if (info && info->getConferenceMemberCount() > 1) {
+ m_confTypeCallReq = flag;
+ }
+
return convertCMResult(
cm_end_call(*m_callClient, callId, convertCUICallReleaseType(type)));
}
return m_rejectMsgProvider;
}
- Result CallManager::processEndCallEvent(cm_call_event_data_h callEventData)
+ Result CallManager::processEndCallEvent(unsigned int callId,
+ cm_call_data_h cmIncom,
+ cm_call_data_h cmActive,
+ cm_call_data_h cmHeld)
{
- unsigned int callId = 0;
- FAIL_RETURN(convertCMResult(
- cm_call_event_data_get_call_id(callEventData, &callId)),
- "cm_call_event_data_get_call_id() failed!");
-
- Result res = RES_OK;
- if (m_incomingCall && callId == m_incomingCall->getInfo()->getCallId()) {
- res = updateCall(m_endCall, m_incomingCall->getInfo());
- m_incomingCall.reset();
- } else if (m_activeCall && callId == m_activeCall->getInfo()->getCallId()) {
- res = updateCall(m_endCall, m_activeCall->getInfo());
- m_activeCall.reset();
- } else if (m_heldCall && callId == m_heldCall->getInfo()->getCallId()) {
- res = updateCall(m_endCall, m_heldCall->getInfo());
- m_heldCall.reset();
- } else if (m_activeCall && m_activeCall->getInfo()->getConferenceMemberCount() > 1) {
- res = updateCall(m_endCall, m_activeCall->getInfo());
- m_activeCall.reset();
- } else if (m_heldCall && m_heldCall->getInfo()->getConferenceMemberCount() > 1) {
- res = updateCall(m_endCall, m_heldCall->getInfo());
- m_heldCall.reset();
+ if (m_activeCall &&
+ callId == m_activeCall->getInfo()->getCallId() &&
+ !cmIncom && !cmActive && !cmHeld) {
+ return updateCall(m_endCall, m_activeCall->getInfo());
+ } else if (m_heldCall &&
+ callId == m_heldCall->getInfo()->getCallId() &&
+ !cmIncom && !cmActive && !cmHeld) {
+ return updateCall(m_endCall, m_heldCall->getInfo());
+ } else if (m_activeCall &&
+ m_confTypeCallReq == CALL_FLAG_ACTIVE) {
+
+ m_confTypeCallReq = CALL_FLAG_NONE;
+ m_blockCMEvents = true;
+
+ return updateCall(m_endCall, m_activeCall->getInfo());
+ } else if (m_heldCall &&
+ m_confTypeCallReq == CALL_FLAG_HELD) {
+
+ m_confTypeCallReq = CALL_FLAG_NONE;
+ m_blockCMEvents = true;
+
+ return updateCall(m_endCall, m_heldCall->getInfo());
}
-
- return res;
+ return RES_OK;
}
- Result CallManager::processCommonCallEvent(cm_call_event_data_h callEventData, CallEventType type)
+ Result CallManager::processCommonCallEvent(unsigned int callId,
+ cm_call_data_h cmIncom,
+ cm_call_data_h cmActive,
+ cm_call_data_h cmHeld)
{
- unsigned int callId = 0;
- cm_call_data_h cmIncom = nullptr;
- cm_call_data_h cmActive = nullptr;
- cm_call_data_h cmHeld = nullptr;
+ if (m_blockCMEvents) {
+ ILOG("Ignore call manager state");
- FAIL_RETURN(convertCMResult(
- cm_call_event_data_get_call_id(callEventData, &callId)),
- "cm_call_event_data_get_call_id() failed!");
-
- FAIL_RETURN(convertCMResult(
- cm_call_event_data_get_incom_call(callEventData, &cmIncom)),
- "cm_call_event_data_get_incom_call() failed!");
-
- FAIL_RETURN(convertCMResult(
- cm_call_event_data_get_active_call(callEventData, &cmActive)),
- "cm_call_event_data_get_active_call() failed!");
+ m_incomingCall.reset();
+ m_activeCall.reset();
+ m_heldCall.reset();
- FAIL_RETURN(convertCMResult(
- cm_call_event_data_get_held_call(callEventData, &cmHeld)),
- "cm_call_event_data_get_held_call() failed!");
+ return RES_OK;
+ }
FAIL_RETURN(updateCall(m_incomingCall, cmIncom), "updateCall() failed!");
FAIL_RETURN(updateCall(m_activeCall, cmActive), "updateCall() failed!");
DLOG("Call event changed on [%d]", type);
+ if (m_blockCMEvents) {
+ if (type == CallEventType::END) {
+ ILOG("Ignore call manager state");
+ return;
+ } else {
+ m_blockCMEvents = false;
+ }
+ }
+
if (m_slot == SimSlot::UNDEFINED) {
cm_multi_sim_slot_type_e cmSimSlot;
FAIL_RETURN_VOID(convertCMResult(
m_slot = convertCMSimSlot(cmSimSlot);
}
+ unsigned int callId = 0;
+ cm_call_data_h cmIncom = nullptr;
+ cm_call_data_h cmActive = nullptr;
+ cm_call_data_h cmHeld = nullptr;
+
+ FAIL_RETURN_VOID(convertCMResult(
+ cm_call_event_data_get_call_id(callEventData, &callId)),
+ "cm_call_event_data_get_call_id() failed!");
+
+ FAIL_RETURN_VOID(convertCMResult(
+ cm_call_event_data_get_incom_call(callEventData, &cmIncom)),
+ "cm_call_event_data_get_incom_call() failed!");
+
+ FAIL_RETURN_VOID(convertCMResult(
+ cm_call_event_data_get_active_call(callEventData, &cmActive)),
+ "cm_call_event_data_get_active_call() failed!");
+
+ FAIL_RETURN_VOID(convertCMResult(
+ cm_call_event_data_get_held_call(callEventData, &cmHeld)),
+ "cm_call_event_data_get_held_call() failed!");
+
m_endCall.reset();
switch (type) {
case CallEventType::END:
- FAIL_RETURN_VOID(processEndCallEvent(callEventData),
+ FAIL_RETURN_VOID(processEndCallEvent(callId,
+ cmIncom,
+ cmActive,
+ cmHeld),
"processEndCallEvent() failed!");
case CallEventType::ACTIVE:
case CallEventType::INCOMING:
case CallEventType::SWAPPED:
case CallEventType::JOIN:
case CallEventType::SPLIT:
- FAIL_RETURN_VOID(processCommonCallEvent(callEventData, type),
+ FAIL_RETURN_VOID(processCommonCallEvent(callId,
+ cmIncom,
+ cmActive,
+ cmHeld),
"processCommonCallEvent() failed!");
break;
default:
template <class TYPE, class TYPE2>
ucl::Result updateCall(ucl::SharedRef<TYPE> &call, TYPE2 &&data);
- ucl::Result processEndCallEvent(cm_call_event_data_h callEventData);
- ucl::Result processCommonCallEvent(cm_call_event_data_h callEventData,
- CallEventType type);
+ ucl::Result processEndCallEvent(unsigned int callId,
+ cm_call_data_h cmIncom,
+ cm_call_data_h cmActive,
+ cm_call_data_h cmHeld);
+
+ ucl::Result processCommonCallEvent(unsigned int callId,
+ cm_call_data_h cmIncom,
+ cm_call_data_h cmActive,
+ cm_call_data_h cmHeld);
+
void callEventCb(cm_call_event_e call_event, cm_call_event_data_h call_state_data);
void dialStatusCb(cm_dial_status_e status);
EndCallSRef m_endCall;
SimSlot m_slot;
bool m_waitDialing;
+
+ int m_confTypeCallReq;
+ bool m_blockCMEvents;
};
}
EndCall::EndCall(CallManagerWRef cm, ICallInfoSCRef callInfo):
m_cm(cm),
- m_callInfo(callInfo)
+ m_callInfo(callInfo),
+ m_callbackInProgress(false)
{
}
Result EndCall::callBack()
{
+ if (m_callbackInProgress) {
+ LOG_RETURN(RES_OK, "Callback already in progress");
+ }
+
if (!m_cm) {
LOG_RETURN(RES_FAIL, "Call Manager is NULL");
}
- return m_cm->dialVoiceCall(m_callInfo->getPhoneNumber());
+
+ auto res = m_cm->dialVoiceCall(m_callInfo->getPhoneNumber());
+ if (res == RES_OK) {
+ m_callbackInProgress = true;
+ }
+ return res;
}
Result EndCall::writeMessage()
private:
CallManagerWRef m_cm;
ICallInfoSCRef m_callInfo;
+ bool m_callbackInProgress;
};
}
using namespace ucl;
CallInfoPresenter::Builder::Builder():
- m_mode(CallInfoMode::UNDEFINED)
+ m_mode(CallMode::UNDEFINED)
{
}
return *this;
}
- CallInfoPresenter::Builder &CallInfoPresenter::Builder::setMode(CallInfoMode mode)
+ CallInfoPresenter::Builder &CallInfoPresenter::Builder::setMode(CallMode mode)
{
m_mode = mode;
return *this;
CallInfoPresenterSRef CallInfoPresenter::Builder::build(ElmWidget &parent) const
{
- if (m_mode == CallInfoMode::UNDEFINED || !m_cm) {
+ if (m_mode == CallMode::UNDEFINED || !m_cm) {
LOG_RETURN_VALUE(RES_FAIL, {}, "Not all params are set");
}
CallInfoPresenter::CallInfoPresenter(RefCountObjBase &rc,
const ICallManagerSRef &cm,
- CallInfoMode mode):
+ CallMode mode):
Presenter(rc),
m_mode(mode),
m_isCallerIdEnable(false),
return *m_widget;
}
- CallInfoMode CallInfoPresenter::getMode() const
+ CallMode CallInfoPresenter::getMode() const
{
return m_mode;
}
}
}
- Result CallInfoPresenter::update(CallInfoMode mode, const ICallManagerSRef &cm)
+ Result CallInfoPresenter::update(CallMode mode, const ICallManagerSRef &cm)
{
m_needModifyCallStatus = false;
- if (mode != m_mode || mode == CallInfoMode::DURING) {
+ if (mode != m_mode || mode == CallMode::DURING) {
m_needModifyCallStatus = true;
}
m_mode = mode;
initCallInfos(cm);
+ m_isCallerIdEnable = false;
+ m_isEmergency = false;
+ m_isSubTxtEnable = false;
return update();
}
m_callerId.reset();
m_widget->emit(impl::SIGN_CALLER_ID_DISABLE, impl::SRC_CALLER_ID);
- if (m_mode == CallInfoMode::INCOMING) {
+ if (m_mode == CallMode::INCOMING) {
if (!m_incomCallInfo) {
LOG_RETURN(RES_FAIL, "m_incomCallInfo is NULL");
{
std::string subTxt;
m_isSubTxtEnable = false;
-
m_label.reset();
switch (m_mode) {
- case CallInfoMode::INCOMING:
+ case CallMode::INCOMING:
subTxt = getIncomingCallSubText();
break;
- case CallInfoMode::DURING:
+ case CallMode::DURING:
subTxt = getDuringCallSubText();
break;
- case CallInfoMode::OUTGOING:
+ case CallMode::OUTGOING:
ILOG("Outgoing call not supported");
break;
- case CallInfoMode::END:
+ case CallMode::END:
subTxt = getEndCallSubText();
break;
- case CallInfoMode::UNDEFINED:
+ case CallMode::UNDEFINED:
LOG_RETURN(RES_FAIL, "Undefined caller info mode!");
break;
default:
m_widget->emit(impl::SIGN_CALLER_ID_DISABLE, impl::SRC_TXT_1LINE);
- if (m_mode == CallInfoMode::END) {
-
- if (isMainTxtSingleLine) {
- m_widget->emit(impl::SIGN_1LINE, impl::SRC_TOP_PAD);
- } else {
- m_widget->emit(impl::SIGN_2LINE, impl::SRC_TOP_PAD);
-
- }
- } else if (m_mode == CallInfoMode::INCOMING) {
+ if (m_isEmergency) {
+ m_widget->emit(impl::SIGN_EMERGENCY_MODE, impl::SRC_TXT_1LINE);
+ }
+ if (m_mode == CallMode::INCOMING) {
if (m_isCallerIdEnable) {
m_widget->emit(impl::SIGN_CALLER_ID_ENABLE, impl::SRC_TXT_1LINE);
} else {
}
} else {
-
- if (m_isEmergency) {
- m_widget->emit(impl::SIGN_EMERGENCY_MODE, impl::SRC_TXT_1LINE);
- }
-
if (isMainTxtSingleLine) {
if (m_isSubTxtEnable) {
m_widget->emit(impl::SIGN_1LINE_2TXT, impl::SRC_TOP_PAD);
{
std::string mainTxt;
switch (m_mode) {
- case CallInfoMode::INCOMING:
+ case CallMode::INCOMING:
mainTxt = generateMainTxt(m_incomCallInfo);
break;
- case CallInfoMode::OUTGOING:
+ case CallMode::OUTGOING:
mainTxt = generateMainTxt(m_activeCallInfo);
break;
- case CallInfoMode::DURING:
+ case CallMode::DURING:
if (m_activeCallInfo) {
mainTxt = generateMainTxt(m_activeCallInfo);
} else if (m_heldCallInfo) {
mainTxt = generateMainTxt(m_heldCallInfo);
}
break;
- case CallInfoMode::END:
+ case CallMode::END:
mainTxt = generateMainTxt(m_endCallInfo);
break;
default:
m_callStatus.reset();
switch (m_mode) {
- case CallInfoMode::INCOMING:
+ case CallMode::INCOMING:
callInfo = m_incomCallInfo;
break;
- case CallInfoMode::OUTGOING:
+ case CallMode::OUTGOING:
callInfo = m_activeCallInfo;
break;
- case CallInfoMode::DURING:
+ case CallMode::DURING:
if (m_activeCallInfo) {
callInfo = m_activeCallInfo;
} else if (m_heldCallInfo) {
isOnHold = true;
}
break;
- case CallInfoMode::END:
+ case CallMode::END:
callInfo = m_endCallInfo;
break;
default:
using namespace ucl;
CallStatus::Builder::Builder():
- m_mode(CallInfoMode::UNDEFINED),
+ m_mode(CallMode::UNDEFINED),
m_isOnHold(false)
{
}
{
}
- CallStatus::Builder &CallStatus::Builder::setMode(CallInfoMode mode)
+ CallStatus::Builder &CallStatus::Builder::setMode(CallMode mode)
{
m_mode = mode;
return *this;
CallStatusSRef CallStatus::Builder::build() const
{
- if (m_mode == CallInfoMode::UNDEFINED || !m_ly) {
+ if (m_mode == CallMode::UNDEFINED || !m_ly) {
LOG_RETURN_VALUE(RES_FAIL, {}, "Not all params are set");
}
CallStatus::CallStatus(RefCountObjBase &rc,
const LayoutSRef &layout,
- CallInfoMode mode,
+ CallMode mode,
const ICallInfoWCRef &info,
bool isHeld):
Presenter(rc),
Result CallStatus::prepare()
{
m_ly->emit(impl::SIGN_RESET, impl::SIGN_SRC_DOT);
+ m_ly->setText("", impl::PART_TXT_TEXT_INFO);
switch (m_mode) {
- case CallInfoMode::INCOMING: return processIncomingMode();
- case CallInfoMode::OUTGOING: return processOutgoingMode();
- case CallInfoMode::DURING: return processDuringMode();
- case CallInfoMode::END: return processEndMode();
+ case CallMode::INCOMING: return processIncomingMode();
+ case CallMode::OUTGOING: return processOutgoingMode();
+ case CallMode::DURING: return processDuringMode();
+ case CallMode::END: return processEndMode();
default:
LOG_RETURN(RES_FAIL, "Unknown mode");
break;
#include "model/IEndCall.h"
#include "model/IIndicatorStateProvider.h"
#include "model/ICallInfo.h"
+#include "model/IRejectMsgProvider.h"
#include "presenters/Indicator.h"
#include "presenters/AcceptRejectPresenter.h"
using namespace ucl;
+ constexpr double CU_RECALL_BTN_SHOW_TIMEOUT = 1.0;
+ constexpr double CU_EXIT_APP_TIMEOUT = 4.0;
+
constexpr LayoutTheme LAYOUT_MAIN_WIDGET
{"layout", "callui", "main"};
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_BOTTOM_BTN {"swl.bottom_btn"};
constexpr EdjePart PART_SWL_OVERLAY {"swl.overlay"};
- constexpr EdjePart PART_TXT_REJECT_MSG{"reject_msg_text"};
+ constexpr EdjePart PART_TXT_REJECT_MSG {"reject_msg_text"};
+
+ constexpr ElmStyle STYLE_BB_END_CALL {"callui/end_call"};
+ constexpr ElmStyle STYLE_BB_RECALL {"callui/call_back"};
+
+ constexpr SmartEvent EVENT_CLICKED {"clicked"};
}}}
namespace callui {
const ExitRequestHandler onExitRequest,
const ICallSRef &call) :
Page(rc, navi, onExitRequest),
- m_call(call)
+ m_call(call),
+ m_mode(CallMode::UNDEFINED),
+ m_ecTimer(nullptr),
+ m_ecTimerBtnReq(false)
{
}
Result MainPage::prepare()
{
+ m_cm = m_call->getCallManager();
+ if (!m_cm) {
+ LOG_RETURN(RES_FAIL, "Call manager is NULL!");
+ }
+
m_widget = Layout::Builder().
setTheme(impl::LAYOUT_MAIN_WIDGET).
setIsOwner(true).
if (!m_indicator) {
LOG_RETURN(RES_FAIL, "Indicator::build() failed!");
}
+
m_widget->setContent(m_indicator->getWidget().getEo(), impl::PART_SWL_INDICATOR);
return Page::prepare([this]() {
void MainPage::onBackKey()
{
- auto callMng = m_call->getCallManager();
- if (m_call->getCallManager()->getAvailableCalls()
+ if (m_cm->getAvailableCalls()
== CALL_FLAG_END) {
requestExit();
}
}
- Result MainPage::processIncomingCall(const IIncomingCallSRef &incom)
+ Result MainPage::processIncomingCall()
{
+ auto incom = m_cm->getIncomingCall();
+ if (!incom) {
+ LOG_RETURN(RES_FAIL, "incom is NULL");
+ }
+
+ auto provider = incom->getRejectMsgProvider();
+ if (!provider) {
+ LOG_RETURN(RES_FAIL, "Reject message provider is NULL");
+ }
+
FAIL_RETURN(createAcceptRejectPresenter(),
"createAcceptRejectPresenter() failed!");
- if (!isUnknownCaller(*incom->getInfo())) {
+ if (!isUnknownCaller(*incom->getInfo())
+ && (provider->getMsgCount() > 0)) {
m_rmLy = Layout::Builder().
setTheme(impl::LAYOUT_REJECT_MSG_WIDGET).
setIsOwner(true).
m_widget->setContent(m_rmLy->getEo(), impl::PART_SWL_REJECT_MSG);
- FAIL_RETURN(createRejectMsgPresenter(incom),
+ FAIL_RETURN(createRejectMsgPresenter(provider),
"createRejectMsgPresenter() failed!");
}
return RES_OK;
}
- void MainPage::onCallEvent(CallEventType type)
+ void MainPage::updateCallMode()
{
- ILOG("CallEventType [%d]", static_cast<int>(type));
+ auto incom = m_cm->getIncomingCall();
+ auto active = m_cm->getActiveCall();
+ auto held = m_cm->getHeldCall();
+ auto end = m_cm->getEndCall();
- auto cm = m_call->getCallManager();
- auto incom = cm->getIncomingCall();
- auto active = cm->getActiveCall();
- auto held = cm->getHeldCall();
- auto end = cm->getEndCall();
+ m_mode = CallMode::UNDEFINED;
- auto win = getNaviframe().getWindow();
+ 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) {
- LOG_RETURN_VOID(RES_FAIL, "win is NULL");
+ LOG_RETURN(RES_FAIL, "win is NULL");
}
- if ((type == CallEventType::DIALING
- || type == CallEventType::INCOMING)
- && !win->isVisible()) {
+ if (!win->isVisible() &&
+ (m_mode == CallMode::INCOMING
+ || m_mode == CallMode::OUTGOING)) {
show(*win);
}
+ return RES_OK;
+ }
- if (incom) {
- FAIL_RETURN_VOID(processIncomingCall(incom),
- "processIncomingCall() failed!");
+ void MainPage::onBottomBtnClicked(Widget &widget, void *eventInfo)
+ {
+ auto active = m_cm->getActiveCall();
+ auto held = m_cm->getHeldCall();
+ auto end = m_cm->getEndCall();
+
+ if (active) {
+ active->end();
+ } else if (held) {
+ held->end();
+ } else if (end) {
+ stopEndCallTimer();
+ end->callBack();
+ }
+ }
+
+ void MainPage::startEndCallTimer()
+ {
+ stopEndCallTimer();
+
+ m_ecTimer = ecore_timer_add(
+ impl::CU_RECALL_BTN_SHOW_TIMEOUT,
+ CALLBACK_B(MainPage::onEndCallTimerCb),
+ this);
+ }
+
+ void MainPage::stopEndCallTimer()
+ {
+ m_ecTimerBtnReq = false;
+
+ if (m_ecTimer) {
+ ecore_timer_del(m_ecTimer);
+ m_ecTimer = nullptr;
+ }
+ }
+
+ Result MainPage::createBottomBtn(const ElmStyle &style)
+ {
+ m_bottomBtn = makeShared<StyledWidget>(
+ elm_button_add(*m_widget), true);
+ m_bottomBtn->setStyle(style);
+
+ m_bottomBtn->addEventHandler(impl::EVENT_CLICKED,
+ WEAK_DELEGATE(MainPage::onBottomBtnClicked,
+ asWeak(*this)));
+
+ m_widget->setContent(*m_bottomBtn, impl::PART_SWL_BOTTOM_BTN);
+ show(*m_bottomBtn);
+
+ return RES_OK;
+ }
+
+ Eina_Bool MainPage::onEndCallTimerCb()
+ {
+ auto end = m_cm->getEndCall();
+ if (!end) {
+ requestExit();
+ LOG_RETURN_VALUE(RES_FAIL, ECORE_CALLBACK_CANCEL, "end is NULL");
+ }
+
+ auto info = end->getInfo();
+ if (!m_bottomBtn && !m_ecTimerBtnReq) {
+ if (info && info->getConferenceMemberCount() == 1) {
+ if (createBottomBtn(impl::STYLE_BB_RECALL) != RES_OK) {
+ m_ecTimer = nullptr;
+ requestExit();
+ LOG_RETURN_VALUE(RES_FAIL, ECORE_CALLBACK_CANCEL,
+ "createBottomBtn() failed!");
+ }
+ }
+ ecore_timer_interval_set(m_ecTimer, impl::CU_EXIT_APP_TIMEOUT);
+ m_ecTimerBtnReq = true;
+ return ECORE_CALLBACK_RENEW;
} else {
- m_rmPrs.reset();
- m_acceptRejectPrs.reset();
- m_rmLy.reset();
+ m_ecTimer = nullptr;
+ requestExit();
+ return ECORE_CALLBACK_CANCEL;
}
+ }
- CallInfoMode mode = CallInfoMode::UNDEFINED;
- if (incom) {
- mode = CallInfoMode::INCOMING;
- } else if (active && active->isDialingMode()) {
- mode = CallInfoMode::OUTGOING;
- } else if (active || held) {
- mode = CallInfoMode::DURING;
- } else if (end) {
- mode = CallInfoMode::END;
+ void MainPage::onCallEvent(CallEventType type)
+ {
+ ILOG("CallEventType [%d]", static_cast<int>(type));
+
+ stopEndCallTimer();
+
+ updateCallMode();
+ if (m_mode == CallMode::UNDEFINED) {
+ requestExit();
+ return;
}
- FAIL_RETURN_VOID(createCallInfoPresenter(mode),
- "createCallInfoPresenter() failed!");
+ FAIL_RETURN_VOID(showWindow(), "showWindow failed!");
+ m_bottomBtn.reset();
- if (type == CallEventType::END) {
- if (m_call->getCallManager()->getAvailableCalls()
- == CALL_FLAG_END) {
- requestExit();
+ if (m_mode == CallMode::INCOMING) {
+ FAIL_RETURN_VOID(processIncomingCall(),
+ "processIncomingCall() failed!");
+ } else {
+ m_rmPrs.reset();
+ m_acceptRejectPrs.reset();
+ m_rmLy.reset();
+
+ if (m_mode == CallMode::END) {
+ startEndCallTimer();
+ } else {
+ createBottomBtn(impl::STYLE_BB_END_CALL);
}
}
+
+ FAIL_RETURN_VOID(createCallInfoPresenter(m_mode),
+ "createCallInfoPresenter() failed!");
}
Result MainPage::createAcceptRejectPresenter()
{
- auto callMng = m_call->getCallManager();
-
if (m_acceptRejectPrs) {
- m_acceptRejectPrs->update(callMng->getAvailableCalls());
+ m_acceptRejectPrs->update(m_cm->getAvailableCalls());
return RES_OK;
}
m_acceptRejectPrs = AcceptRejectPresenter::Builder().
- setIncomingCall(callMng->getIncomingCall()).
- setAvailableCallsFlag(callMng->getAvailableCalls()).
+ setIncomingCall(m_cm->getIncomingCall()).
+ setAvailableCallsFlag(m_cm->getAvailableCalls()).
build(*m_widget);
if (!m_acceptRejectPrs) {
void MainPage::RejectMsgSelectCb(const IRejectMsgSRef &rm)
{
- auto callMng = m_call->getCallManager();
- auto incom = callMng->getIncomingCall();
-
+ auto incom = m_cm->getIncomingCall();
if (incom) {
incom->rejectWithMessage(rm);
}
}
- Result MainPage::createRejectMsgPresenter(const IIncomingCallSRef &incom)
+ Result MainPage::createRejectMsgPresenter(const IRejectMsgProviderSRef &provider)
{
m_rmPrs = RejectMsgPresenter::Builder().
- setProvider(incom->getRejectMsgProvider()).
+ setProvider(provider).
setStateHandler(
WEAK_DELEGATE(MainPage::RejectMsgStateCb,
asWeak(*this))).
return RES_OK;
}
- Result MainPage::createCallInfoPresenter(CallInfoMode mode)
+ Result MainPage::createCallInfoPresenter(CallMode mode)
{
- auto callMng = m_call->getCallManager();
-
if (m_callInfoPrs) {
- return m_callInfoPrs->update(mode, callMng);
+ return m_callInfoPrs->update(mode, m_cm);
}
m_callInfoPrs = CallInfoPresenter::Builder().
- setCallManager(callMng).
+ setCallManager(m_cm).
setMode(mode).
build(*m_widget);
void MainPage::onError(CallErr err)
{
- if (!m_call->getCallManager()->getAvailableCalls()) {
+ if (!m_cm->getAvailableCalls()) {
requestExit();
}
}
using namespace ucl;
+ const int ALPHA_CHANNEL_MAX = 255;
+
constexpr LayoutTheme LAYOUT_DRAWER_PANEL
{"layout", "drawer", "panel"};
elm_scroller_region_show(m_genlist->getEo(), 0, 0, 0, 0);
} else {
m_state = RejectMsgState::IN_TRANSITION;
+ const auto alphaValue =
+ static_cast<int>(impl::ALPHA_CHANNEL_MAX * ev->rel_y);
+ m_panelBg->setColor(0, alphaValue);
if (isActive()) {
deactivateBy(m_widget.get());
sendActivateBy(*m_widget, this);
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<manifest xmlns="http://tizen.org/ns/packages" api-version="3.0" package="org.tizen.call-ui" version="1.0.0">
<profile name="wearable"/>
- <ui-application appid="org.tizen.call-ui" exec="call-ui" multiple="false" nodisplay="false" taskmanage="true" type="capp">
+ <ui-application appid="org.tizen.call-ui" exec="call-ui" multiple="false" nodisplay="true" taskmanage="false" type="capp">
<label>call-ui</label>
<icon>call-ui.png</icon>
<app-control>
projects / profile / wearable / apps / native / call-ui.git / commitdiff
