#include "ucl/appfw/SysEventProvider.h"
+
+#include "model/Call.h"
+
namespace callui {
class Instance :
ucl::SysEventProvider &m_sysEventProvider;
ucl::IInstanceContext *m_context;
ucl::WindowSRef m_win;
+
+ CallSRef m_call;
};
}
class IActiveCall : public ucl::Polymorphic {
public:
virtual ICallInfoSCRef getInfo() const = 0;
- virtual bool isDialingMode() const = 0;
virtual ucl::Result hold() = 0;
virtual ucl::Result end() = 0;
virtual ucl::Result split(const IConferenceCallInfoSRef &confCallInfo) = 0;
class ICallInfo : public ucl::Polymorphic {
public:
+ virtual unsigned int getCallId() const = 0;
virtual const std::string &getPhoneNumber() const = 0;
virtual IContactInfoSCRef getContactInfo() const = 0;
virtual long getStartTime() const = 0;
virtual IActiveCallWRef getActiveCall() = 0;
virtual IHeldCallWRef getHeldCall() = 0;
virtual IEndCallWRef getEndCall() = 0;
- virtual CallMask getAvailableCallMask() const = 0;
- virtual void addCallStateHandler(const CallStateHandler handler) = 0;
- virtual void removeCallStateHandler(const CallStateHandler handler) = 0;
+ virtual void addCallStateHandler(CallStateHandler handler) = 0;
+ virtual void removeCallStateHandler(CallStateHandler handler) = 0;
};
}
class IConferenceCallInfo : public ucl::Polymorphic {
public:
+ virtual unsigned int getCallId() const = 0;
virtual const std::string &getPhoneNumber() const = 0;
virtual IContactInfoSRef getContactInfo() const = 0;
};
virtual ICallInfoSCRef getInfo() const = 0;
virtual ucl::Result answer(CallAnswerType type) = 0;
virtual ucl::Result reject() = 0;
- virtual ucl::Result rejectWithMessage(const std::string &message) = 0;
virtual ucl::Result stopAlert() = 0;
};
}
eext_object_event_callback_add(*m_win, EEXT_CALLBACK_BACK,
CALLBACK_A(Instance::onBack), this);
+ m_call = Call::newInstance();
+
return RES_OK;
}
#include "CallClient.h"
#include "CallManager.h"
+#include "CallClient.h"
#include "CallInfo.h"
#include "common.h"
using namespace ucl;
- ActiveCall::ActiveCall(CallManager &cm):
+ ActiveCall::ActiveCall(CallManager &cm, cm_call_data_h callData):
+ BaseCall(callData),
m_cm(cm)
{
}
+
ActiveCall::~ActiveCall()
{
}
LOG_RETURN_VALUE(RES_FAIL, {}, "callData is NULL");
}
- auto result = makeShared<ActiveCall>(cm);
- FAIL_RETURN_VALUE(result->prepare(callData), {}, "result->prepare() failed!");
+ auto result = makeShared<ActiveCall>(cm, callData);
+ FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
return result;
}
- Result ActiveCall::prepare(cm_call_data_h callData)
+ Result ActiveCall::prepare()
{
- m_callInfo = CallInfo::newInstance(*m_cm.getCallClient(), callData);
+ m_callInfo = CallInfo::newInstance(*m_cm.getCallClient(), m_callData);
if (!m_callInfo) {
LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "CallInfo::newInstance() failed!");
}
return m_callInfo;
}
- bool ActiveCall::isDialingMode() const
- {
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
- }
-
Result ActiveCall::hold()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return convertCallManagerResult(cm_hold_call(*m_cm.getCallClient()));
}
Result ActiveCall::end()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return m_cm.endCall(0, CallReleaseType::ALL_ACTIVE);
}
Result ActiveCall::split(const IConferenceCallInfoSRef &confCallInfo)
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return m_cm.splitCalls(m_callInfo, confCallInfo);
}
}
#include <call-manager-ext.h>
+#include "BaseCall.h"
#include "model/IActiveCall.h"
#include "implTypes.h"
namespace callui {
- class ActiveCall final : public IActiveCall {
+ class ActiveCall final :
+ public BaseCall,
+ public IActiveCall {
public:
static ActiveCallSRef newInstance(CallManager &cm, cm_call_data_h callData);
virtual ~ActiveCall();
// IActiveCall
virtual ICallInfoSCRef getInfo() const override final;
- virtual bool isDialingMode() const override final;
virtual ucl::Result hold() override final;
virtual ucl::Result end() override final;
virtual ucl::Result split(const IConferenceCallInfoSRef &confCallInfo) override final;
private:
friend class ucl::RefCountObj<ActiveCall>;
- ActiveCall(CallManager &cm);
+ ActiveCall(CallManager &cm, cm_call_data_h callData);
- ucl::Result prepare(cm_call_data_h callData);
+ ucl::Result prepare();
private:
CallManager &m_cm;
--- /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 "BaseCall.h"
+
+namespace callui {
+
+ BaseCall::BaseCall(cm_call_data_h callData):
+ m_callData(callData)
+ {
+ }
+
+ BaseCall::~BaseCall()
+ {
+ }
+
+ cm_call_data_h BaseCall::getCallData()
+ {
+ return m_callData;
+ }
+
+}
--- /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_MODEL_BASE_CALL_H__
+#define __CALLUI_MODEL_BASE_CALL_H__
+
+#include <call-manager-ext.h>
+
+namespace callui {
+
+ class BaseCall {
+ public:
+ BaseCall(cm_call_data_h callData);
+ virtual ~BaseCall();
+
+ cm_call_data_h getCallData();
+ protected:
+ cm_call_data_h m_callData;
+ };
+
+}
+
+#endif // __CALLUI_MODEL_BASE_CALL_H__
ICallManagerSRef Call::getCallManager()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return m_callManager;
}
ISoundManagerSRef Call::getSoundManager()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return m_soundManager;
}
}
#include "CallClient.h"
#include "common.h"
-#include "helpers.h"
namespace callui {
#include "CallClient.h"
#include "common.h"
-#include "helpers.h"
namespace callui {
#include "ConferenceCallInfo.h"
#include "common.h"
-#include "helpers.h"
namespace callui {
return res;
}
- unsigned int CallInfo::getCallId()
+ unsigned int CallInfo::getCallId() const
{
return m_callId;
}
static CallInfoSRef newInstance(CallClient &client, cm_call_data_h callData);
virtual ~CallInfo();
- unsigned int getCallId();
-
// ICallInfo
+ virtual unsigned int getCallId() const override final;
virtual const std::string &getPhoneNumber() const override final;
virtual IContactInfoSCRef getContactInfo() const override final;
virtual long getStartTime() const override final;
#include "CallManager.h"
-#include <call-manager-ext.h>
-#include <call-manager-extension.h>
-
#include "CallClient.h"
#include "CallDialer.h"
+
#include "IncomingCall.h"
#include "ActiveCall.h"
#include "HeldCall.h"
#include "EndCall.h"
-#include "helpers.h"
+#include "CallInfo.h"
+#include "ConferenceCallInfo.h"
+
#include "common.h"
namespace callui {
using namespace ucl;
CallManager::CallManager(const CallClientSRef &client):
- m_client(client),
- m_availableCalls(0)
+ m_client(client)
{
}
CallManager::~CallManager()
{
- ILOG();
}
CallManagerSRef CallManager::newInstance(const CallClientSRef &client)
LOG_RETURN(RES_FAIL, "CallDialer::getInstance() failed!");
}
- Result res = updateCalls();
- FAIL_RETURN_VALUE(res, res, "updateCalls() failed");
+ FAIL_RETURN(initCalls(), "initCalls() failed!");
- return RES_OK;
- }
+ FAIL_RETURN(convertCallManagerResult(
+ cm_set_call_event_cb(*m_client, CALLBACK_B(CallManager::callEventCb), this)),
+ "cm_set_call_event_cb() failed!");
- void CallManager::resetCalls()
- {
- m_incomingCall.reset();
- m_activeCall.reset();
- m_heldCall.reset();
- m_endCall.reset();
-
- m_availableCalls = 0;
+ return RES_OK;
}
- Result CallManager::updateCalls()
+ Result CallManager::initCalls()
{
- resetCalls();
-
cm_call_data_h incom = nullptr;
cm_call_data_h active = nullptr;
cm_call_data_h held = nullptr;
- Result res = convertCallManagerResult(cm_get_all_calldata(*m_client, &incom, &active, &held));
- FAIL_RETURN_VALUE(res, res, "cm_get_all_calldata() failed");
+ FAIL_RETURN(convertCallManagerResult(
+ cm_get_all_calldata(*m_client, &incom, &active, &held)),
+ "cm_get_all_calldata() failed!");
+
+ FAIL_RETURN(updateIncomingCall(incom), "updateIncomingCall() failed!");
+ FAIL_RETURN(updateActiveCall(active), "updateActiveCall() failed!");
+ FAIL_RETURN(updateHeldCall(held), "updateHeldCall() failed!");
+
+ return RES_OK;
+ }
+
+ Result CallManager::updateIncomingCall(cm_call_data_h incom, SimSlot slot)
+ {
if (incom) {
- m_incomingCall = IncomingCall::newInstance(*this, incom);
+ m_incomingCall = IncomingCall::newInstance(*this, incom, slot);
if (!m_incomingCall) {
LOG_RETURN(RES_FAIL, "IncomingCall::newInstance() failed!");
}
- m_availableCalls |= CALL_FLAG_INCOMING;
+ } else {
+ m_incomingCall.reset();
}
+ return RES_OK;
+ }
+
+ Result CallManager::updateActiveCall(cm_call_data_h active)
+ {
if (active) {
m_activeCall = ActiveCall::newInstance(*this, active);
if (!m_activeCall) {
LOG_RETURN(RES_FAIL, "ActiveCall::newInstance() failed!");
}
- m_availableCalls |= CALL_FLAG_ACTIVE;
+ } else {
+ m_activeCall.reset();
}
+ return RES_OK;
+ }
+
+ Result CallManager::updateHeldCall(cm_call_data_h held)
+ {
if (held) {
m_heldCall = HeldCall::newInstance(*this, held);
if (!m_heldCall) {
LOG_RETURN(RES_FAIL, "HeldCall::newInstance() failed!");
}
- m_availableCalls |= CALL_FLAG_HELD;
+ } else {
+ m_heldCall.reset();
}
- // TODO: need to implement End Call logic according to system call manager events
-
return RES_OK;
+ }
+
+ Result CallManager::updateEndCall(cm_call_data_h end, SimSlot slot)
+ {
+ if (end) {
+ m_endCall = EndCall::newInstance(*this, end, slot);
+ if (!m_endCall) {
+ LOG_RETURN(RES_FAIL, "EndCall::newInstance() failed!");
+ }
+ } else {
+ m_endCall.reset();
+ }
+ return RES_OK;
}
CallClientSRef CallManager::getCallClient()
return m_endCall;
}
- CallMask CallManager::getAvailableCallMask() const
+ void CallManager::addCallStateHandler(CallStateHandler handler)
{
- return m_availableCalls;
+ m_event += handler;
}
- void CallManager::addCallStateHandler(const CallStateHandler handler)
+ void CallManager::removeCallStateHandler(CallStateHandler handler)
{
- m_event += handler;
+ m_event -= handler;
}
- void CallManager::removeCallStateHandler(const CallStateHandler handler)
+ Result CallManager::endCall(unsigned int callId, CallReleaseType type)
{
- m_event -= handler;
+ return convertCallManagerResult(
+ cm_end_call(*m_client, callId, convertCallAppReleaseType(type)));
+ }
+
+ Result CallManager::splitCalls(CallInfoSRef callInfo, const IConferenceCallInfoSRef &confCallInfo)
+ {
+ if (callInfo->getConferenceMemberCount() <= 1) {
+ LOG_RETURN(RES_FAIL, "Not conference call");
+ }
+
+ auto confList = callInfo->getConferenceMemberList();
+ auto iter = std::find(confList.begin(), confList.end(), confCallInfo);
+ if (iter == confList.end()) {
+ LOG_RETURN(RES_FAIL, "Not a member of conference call");
+ }
+
+ return endCall((*iter)->getCallId(), CallReleaseType::BY_CALL_HANDLE);
+ }
+
+ Result CallManager::processEndCallEvent(cm_call_event_data_h callEventData, SimSlot simSlot)
+ {
+ unsigned int callId = 0;
+ FAIL_RETURN(convertCallManagerResult(
+ 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 = updateEndCall(m_incomingCall->getCallData(), simSlot);
+ m_incomingCall.reset();
+ } else if (m_activeCall && callId == m_activeCall->getInfo()->getCallId()) {
+ res = updateEndCall(m_activeCall->getCallData(), simSlot);
+ m_activeCall.reset();
+ } else if (m_heldCall && callId == m_heldCall->getInfo()->getCallId()) {
+ res = updateEndCall(m_heldCall->getCallData(), simSlot);
+ m_heldCall.reset();
+ } else if (m_activeCall && m_activeCall->getInfo()->getConferenceMemberCount() > 1) {
+ res = updateEndCall(m_activeCall->getCallData(), simSlot);
+ m_activeCall.reset();
+ } else if (m_heldCall && m_heldCall->getInfo()->getConferenceMemberCount() > 1) {
+ res = updateEndCall(m_heldCall->getCallData(), simSlot);
+ m_heldCall.reset();
+ }
+
+ return res;
+ }
+
+ Result CallManager::processCommonCallEvent(cm_call_event_data_h callEventData, CallEventType type, SimSlot simSlot)
+ {
+ unsigned int callId = 0;
+ cm_call_data_h cmIncom = nullptr;
+ cm_call_data_h cmActive = nullptr;
+ cm_call_data_h cmHeld = nullptr;
+
+ FAIL_RETURN(convertCallManagerResult(
+ cm_call_event_data_get_call_id(callEventData, &callId)),
+ "cm_call_event_data_get_call_id() failed!");
+
+ FAIL_RETURN(convertCallManagerResult(
+ cm_call_event_data_get_incom_call(callEventData, &cmIncom)),
+ "cm_call_event_data_get_incom_call() failed!");
+
+ FAIL_RETURN(convertCallManagerResult(
+ cm_call_event_data_get_active_call(callEventData, &cmActive)),
+ "cm_call_event_data_get_active_call() failed!");
+
+ FAIL_RETURN(convertCallManagerResult(
+ cm_call_event_data_get_held_call(callEventData, &cmHeld)),
+ "cm_call_event_data_get_held_call() failed!");
+
+ if (type == CallEventType::INCOMING) {
+ FAIL_RETURN(updateIncomingCall(cmIncom, simSlot), "updateIncomingCall() failed!");
+ } else if (!cmIncom) {
+ m_incomingCall.reset();
+ }
+ FAIL_RETURN(updateActiveCall(cmActive), "updateActiveCall() failed!");
+ FAIL_RETURN(updateHeldCall(cmHeld), "updateHeldCall() failed!");
+
+ return RES_OK;
+ }
+
+ void CallManager::callEventCb(cm_call_event_e callEvent, cm_call_event_data_h callEventData)
+ {
+ if (!callEventData) {
+ ELOG("callEventData is NULL");
+ return;
+ }
+
+ CallEventType type;
+ FAIL_RETURN_VOID(convertCallManagerEventType(callEvent, &type),
+ "convertCallManagerEventType() failed!");
+
+ DLOG("Call event changed on [%d]", type);
+
+ cm_multi_sim_slot_type_e cmSimSlot;
+ FAIL_RETURN_VOID(convertCallManagerResult(
+ cm_call_event_data_get_sim_slot(callEventData, &cmSimSlot)),
+ "cm_call_event_data_get_sim_slot() failed!");
+ SimSlot simSlot = convertCallManagerSimSlot(cmSimSlot);
+
+ m_endCall.reset();
+
+ switch (type) {
+ case CallEventType::END:
+ FAIL_RETURN_VOID(processEndCallEvent(callEventData, simSlot),
+ "processEndCallEvent() failed!");
+ case CallEventType::ACTIVE:
+ case CallEventType::INCOMING:
+ case CallEventType::DIALING:
+ case CallEventType::HELD:
+ case CallEventType::RETRIEVED:
+ case CallEventType::SWAPPED:
+ case CallEventType::JOIN:
+ case CallEventType::SPLIT:
+ FAIL_RETURN_VOID(processCommonCallEvent(callEventData, type, simSlot),
+ "processCommonCallEvent() failed!");
+ break;
+ default:
+ return;
+ }
+
+ m_event.invoke(type);
}
}
#ifndef __CALLUI_MODEL_CALL_MANAGER_H__
#define __CALLUI_MODEL_CALL_MANAGER_H__
+#include <call-manager-ext.h>
+
#include "ucl/misc/Event.h"
#include "model/ICallManager.h"
virtual ~CallManager();
CallClientSRef getCallClient();
+ ucl::Result endCall(unsigned int callId, CallReleaseType type);
+ ucl::Result splitCalls(CallInfoSRef callInfo, const IConferenceCallInfoSRef &confCallInfo);
// ICallManager
virtual IActiveCallWRef getActiveCall() override final;
virtual IHeldCallWRef getHeldCall() override final;
virtual IEndCallWRef getEndCall() override final;
- virtual CallMask getAvailableCallMask() const override final;
- virtual void addCallStateHandler(const CallStateHandler handler) override final;
- virtual void removeCallStateHandler(const CallStateHandler handler) override final;
+ virtual void addCallStateHandler(CallStateHandler handler) override final;
+ virtual void removeCallStateHandler(CallStateHandler handler) override final;
private:
friend class ucl::RefCountObj<CallManager>;
CallManager(const CallClientSRef &callClient);
ucl::Result prepare();
- ucl::Result updateCalls();
- void resetCalls();
+ ucl::Result initCalls();
+ ucl::Result updateIncomingCall(cm_call_data_h incom, SimSlot slot = SimSlot::DEFAULT);
+ ucl::Result updateActiveCall(cm_call_data_h active);
+ ucl::Result updateHeldCall(cm_call_data_h active);
+ ucl::Result updateEndCall(cm_call_data_h end, SimSlot slot = SimSlot::DEFAULT);
+
+ ucl::Result processEndCallEvent(cm_call_event_data_h callEventData, SimSlot slot);
+ ucl::Result processCommonCallEvent(cm_call_event_data_h callEventData, CallEventType type, SimSlot simSlot);
+ void callEventCb(cm_call_event_e call_event, cm_call_event_data_h call_state_data);
private:
CallClientSRef m_client;
ActiveCallSRef m_activeCall;
HeldCallSRef m_heldCall;
EndCallSRef m_endCall;
- CallMask m_availableCalls;
CallStateEvent m_event;
};
#include "ContactInfo.h"
#include "common.h"
-#include "helpers.h"
namespace callui {
return RES_OK;
}
- unsigned int ConferenceCallInfo::getCallId()
+ unsigned int ConferenceCallInfo::getCallId() const
{
return m_callId;
}
static ConferenceCallInfoSRef newInstance(cm_conf_call_data_t *confCallData);
virtual ~ConferenceCallInfo();
- unsigned int getCallId();
-
// IConferenceCallInfo
+ virtual unsigned int getCallId() const override final;
virtual const std::string &getPhoneNumber() const override final;
virtual IContactInfoSRef getContactInfo() const override final;
#include "ContactInfo.h"
#include "common.h"
-#include "helpers.h"
namespace callui {
#include "CallClient.h"
#include "CallManager.h"
#include "CallInfo.h"
+#include "model/ICallDialer.h"
#include "common.h"
using namespace ucl;
- EndCall::EndCall(CallManager &cm):
- m_cm(cm)
+ EndCall::EndCall(CallManager &cm, cm_call_data_h callData, SimSlot slot):
+ BaseCall(callData),
+ m_cm(cm),
+ m_slot(slot)
{
}
{
}
- EndCallSRef EndCall::newInstance(CallManager &cm, cm_call_data_h callData)
+ EndCallSRef EndCall::newInstance(CallManager &cm, cm_call_data_h callData, SimSlot slot)
{
if (!callData) {
LOG_RETURN_VALUE(RES_FAIL, {}, "callData is NULL");
}
- auto result = makeShared<EndCall>(cm);
- FAIL_RETURN_VALUE(result->prepare(callData), {}, "result->prepare() failed!");
+ auto result = makeShared<EndCall>(cm, callData, slot);
+ FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
return result;
}
- Result EndCall::prepare(cm_call_data_h callData)
+ Result EndCall::prepare()
{
- m_callInfo = CallInfo::newInstance(*m_cm.getCallClient(), callData);
+ m_callInfo = CallInfo::newInstance(*m_cm.getCallClient(), m_callData);
if (!m_callInfo) {
LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "CallInfo::newInstance() failed!");
}
Result EndCall::callBack()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ ICallDialerWRef dialer = m_cm.getDialer();
+ if (dialer) {
+ return dialer->dialVoiceCall(m_callInfo->getPhoneNumber(), m_slot);
+ } else {
+ return RES_FAIL;
+ }
}
Result EndCall::writeMessage()
#include <call-manager-ext.h>
+#include "BaseCall.h"
#include "model/IEndCall.h"
#include "implTypes.h"
class CallManager;
- class EndCall final : public IEndCall {
+ class EndCall final :
+ public BaseCall,
+ public IEndCall {
public:
- static EndCallSRef newInstance(CallManager &cm, cm_call_data_h callData);
+ static EndCallSRef newInstance(CallManager &cm,
+ cm_call_data_h callData,
+ SimSlot slot = SimSlot::DEFAULT);
+
virtual ~EndCall();
// IEndCall
private:
friend class ucl::RefCountObj<EndCall>;
- EndCall(CallManager &cm);
+ EndCall(CallManager &cm, cm_call_data_h callData, SimSlot slot);
- ucl::Result prepare(cm_call_data_h callData);
+ ucl::Result prepare();
private:
CallManager &m_cm;
CallInfoSRef m_callInfo;
+ SimSlot m_slot;
};
}
#include "CallClient.h"
#include "CallManager.h"
#include "CallInfo.h"
+#include "CallClient.h"
#include "common.h"
using namespace ucl;
- HeldCall::HeldCall(CallManager &cm):
+ HeldCall::HeldCall(CallManager &cm, cm_call_data_h callData):
+ BaseCall(callData),
m_cm(cm)
{
}
LOG_RETURN_VALUE(RES_FAIL, {}, "callData is NULL");
}
- auto result = makeShared<HeldCall>(cm);
- FAIL_RETURN_VALUE(result->prepare(callData), {}, "result->prepare() failed!");
+ auto result = makeShared<HeldCall>(cm, callData);
+ FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
return result;
}
- Result HeldCall::prepare(cm_call_data_h callData)
+ Result HeldCall::prepare()
{
- m_callInfo = CallInfo::newInstance(*m_cm.getCallClient(), callData);
+ m_callInfo = CallInfo::newInstance(*m_cm.getCallClient(), m_callData);
if (!m_callInfo) {
LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "CallInfo::newInstance() failed!");
}
Result HeldCall::unhold()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return convertCallManagerResult(cm_unhold_call(*m_cm.getCallClient()));
}
Result HeldCall::joinWithActive()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return convertCallManagerResult(cm_join_call(*m_cm.getCallClient()));
}
Result HeldCall::swapWithActive()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return convertCallManagerResult(cm_swap_call(*m_cm.getCallClient()));
}
Result HeldCall::end()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return m_cm.endCall(0, CallReleaseType::ALL_HOLD);
}
Result HeldCall::split(const IConferenceCallInfoSRef &confCallInfo)
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return m_cm.splitCalls(m_callInfo, confCallInfo);
}
-} /* namespace callui */
+}
#include <call-manager-ext.h>
+#include "BaseCall.h"
#include "model/IHeldCall.h"
#include "implTypes.h"
namespace callui {
- class HeldCall final : public IHeldCall {
+ class HeldCall final :
+ public BaseCall,
+ public IHeldCall {
public:
static HeldCallSRef newInstance(CallManager &cm, cm_call_data_h callData);
virtual ~HeldCall();
private:
friend class ucl::RefCountObj<HeldCall>;
- HeldCall(CallManager &cm);
+ HeldCall(CallManager &cm, cm_call_data_h callData);
- ucl::Result prepare(cm_call_data_h callData);
+ ucl::Result prepare();
private:
CallManager &m_cm;
#include "CallClient.h"
#include "CallManager.h"
+#include "CallClient.h"
#include "CallInfo.h"
#include "common.h"
using namespace ucl;
- IncomingCall::IncomingCall(CallManager &cm):
- m_cm(cm)
+ IncomingCall::IncomingCall(CallManager &cm, cm_call_data_h callData, SimSlot slot):
+ BaseCall(callData),
+ m_cm(cm),
+ m_simSlot(slot)
{
}
{
}
- IncomingCallSRef IncomingCall::newInstance(CallManager &cm, cm_call_data_h callData)
+ IncomingCallSRef IncomingCall::newInstance(CallManager &cm, cm_call_data_h callData, SimSlot slot)
{
if (!callData) {
LOG_RETURN_VALUE(RES_FAIL, {}, "callData is NULL");
}
- auto result = makeShared<IncomingCall>(cm);
- FAIL_RETURN_VALUE(result->prepare(callData), {}, "result->prepare() failed!");
+ auto result = makeShared<IncomingCall>(cm, callData, slot);
+ FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
return result;
}
- Result IncomingCall::prepare(cm_call_data_h callData)
+ Result IncomingCall::prepare()
{
- m_callInfo = CallInfo::newInstance(*m_cm.getCallClient(), callData);
+ m_callInfo = CallInfo::newInstance(*m_cm.getCallClient(), m_callData);
if (!m_callInfo) {
LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "CallInfo::newInstance() failed!");
}
Result IncomingCall::answer(CallAnswerType type)
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return convertCallManagerResult(cm_answer_call(*m_cm.getCallClient(),convertCallAppAnswerType(type)));
}
Result IncomingCall::reject()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
- }
-
- Result IncomingCall::rejectWithMessage(const std::string &message)
- {
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return convertCallManagerResult(cm_reject_call(*m_cm.getCallClient()));
}
Result IncomingCall::stopAlert()
{
- UCL_ASSERT(0, "!!! NOT IMPLEMENTED !!!");
+ return convertCallManagerResult(cm_stop_alert(*m_cm.getCallClient()));
}
}
#include <call-manager-ext.h>
+#include "BaseCall.h"
#include "model/IIncomingCall.h"
#include "implTypes.h"
namespace callui {
- class IncomingCall final : public IIncomingCall {
+ class IncomingCall final :
+ public BaseCall,
+ public IIncomingCall {
public:
- static IncomingCallSRef newInstance(CallManager &cm, cm_call_data_h callData);
+ static IncomingCallSRef newInstance(CallManager &cm,
+ cm_call_data_h callData,
+ SimSlot slot = SimSlot::DEFAULT);
+
virtual ~IncomingCall();
// IIncomingCall
virtual ICallInfoSCRef getInfo() const override final;
virtual ucl::Result answer(CallAnswerType type) override final;
virtual ucl::Result reject() override final;
- virtual ucl::Result rejectWithMessage(const std::string &message) override final;
virtual ucl::Result stopAlert() override final;
private:
friend class ucl::RefCountObj<IncomingCall>;
- IncomingCall(CallManager &cm);
+ IncomingCall(CallManager &cm, cm_call_data_h callData, SimSlot slot);
- ucl::Result prepare(cm_call_data_h callData);
+ ucl::Result prepare();
private:
CallManager &m_cm;
CallInfoSRef m_callInfo;
+ SimSlot m_simSlot;
};
}
#include "CallClient.h"
#include "common.h"
-#include "helpers.h"
namespace callui {
#include "../common.h"
+#include "helpers.h"
+
#endif // __CALLUI_MODEL_COMMON_H__
DialStatus convertCallManagerDialStatus(cm_dial_status_e status);
cm_multi_sim_slot_type_e convertCallAppSimSlot(SimSlot slot);
+
+ SimSlot convertCallManagerSimSlot(cm_multi_sim_slot_type_e slot);
+
+ cm_call_release_type_e convertCallAppReleaseType(CallReleaseType type);
+
+ ucl::Result convertCallManagerEventType(cm_call_event_e cmEvent, CallEventType *appEvent);
+
+ cm_call_answer_type_e convertCallAppAnswerType(CallAnswerType type);
}
#include "helpers.hpp"
return CM_MULTI_SIM_SLOT_DEFAULT;
}
}
+
+ inline SimSlot convertCallManagerSimSlot(cm_multi_sim_slot_type_e slot)
+ {
+ switch (slot) {
+ case CM_MULTI_SIM_SLOT_1: return SimSlot::FIRST;
+ case CM_MULTI_SIM_SLOT_2: return SimSlot::SECOND;
+ default:
+ return SimSlot::DEFAULT;
+ }
+ }
+
+ inline cm_call_release_type_e convertCallAppReleaseType(CallReleaseType type)
+ {
+ switch (type) {
+ case CallReleaseType::BY_CALL_HANDLE: return CM_CALL_RELEASE_TYPE_BY_CALL_HANDLE;
+ case CallReleaseType::ALL: return CM_CALL_RELEASE_TYPE_ALL_CALLS;
+ case CallReleaseType::ALL_HOLD: return CM_CALL_RELEASE_TYPE_ALL_HOLD_CALLS;
+ case CallReleaseType::ALL_ACTIVE: return CM_CALL_RELEASE_TYPE_ALL_ACTIVE_CALLS;
+ default:
+ return CM_CALL_RELEASE_TYPE_BY_CALL_HANDLE;
+ }
+ }
+
+ inline ucl::Result convertCallManagerEventType(cm_call_event_e cmEvent, CallEventType *appEvent)
+ {
+ switch (cmEvent) {
+ case CM_CALL_EVENT_IDLE:
+ *appEvent = CallEventType::END;
+ break;
+ case CM_CALL_EVENT_DIALING:
+ *appEvent = CallEventType::DIALING;
+ break;
+ case CM_CALL_EVENT_ACTIVE:
+ *appEvent = CallEventType::ACTIVE;
+ break;
+ case CM_CALL_EVENT_HELD:
+ *appEvent = CallEventType::HELD;
+ break;
+ case CM_CALL_EVENT_ALERT:
+ *appEvent = CallEventType::ALERT;
+ break;
+ case CM_CALL_EVENT_INCOMING:
+ *appEvent = CallEventType::INCOMING;
+ break;
+ case CM_CALL_EVENT_WAITING:
+ *appEvent = CallEventType::WAITING;
+ break;
+ case CM_CALL_EVENT_JOIN:
+ *appEvent = CallEventType::JOIN;
+ break;
+ case CM_CALL_EVENT_SPLIT:
+ *appEvent = CallEventType::SPLIT;
+ break;
+ case CM_CALL_EVENT_SWAPPED:
+ *appEvent = CallEventType::SWAPPED;
+ break;
+ case CM_CALL_EVENT_RETRIEVED:
+ *appEvent = CallEventType::RETRIEVED;
+ break;
+ case CM_CALL_EVENT_SAT_CALL_CONTROL:
+ *appEvent = CallEventType::SAT_CALL_CONTROL;
+ break;
+ default:
+ return ucl::RES_FAIL;
+ }
+ return ucl::RES_OK;
+ }
+
+ inline cm_call_answer_type_e convertCallAppAnswerType(CallAnswerType type)
+ {
+ switch (type) {
+ case CallAnswerType::NORMAL: return CALL_ANSWER_TYPE_NORMAL;
+ case CallAnswerType::HOLD_ACTIVE_AND_ACCEPT: return CALL_ANSWER_TYPE_HOLD_ACTIVE_AND_ACCEPT;
+ case CallAnswerType::RELEASE_ACTIVE_AND_ACCEPT: return CALL_ANSWER_TYPE_RELEASE_ACTIVE_AND_ACCEPT;
+ case CallAnswerType::RELEASE_HOLD_AND_ACCEPT: return CALL_ANSWER_TYPE_RELEASE_HOLD_AND_ACCEPT;
+ case CallAnswerType::RELEASE_ALL_AND_ACCEPT: return CALL_ANSWER_TYPE_RELEASE_ALL_AND_ACCEPT;
+ default:
+ return CALL_ANSWER_TYPE_NORMAL;
+ }
+ }
}
<label>call-ui</label>
<icon>call-ui.png</icon>
</ui-application>
+ <privileges>
+ <privilege>http://tizen.org/privilege/keygrab</privilege>
+ <privilege>http://tizen.org/privilege/appmanager.launch</privilege>
+ <privilege>http://tizen.org/privilege/window.priority.set</privilege>
+ <privilege>http://tizen.org/privilege/contact.read</privilege>
+ <privilege>http://tizen.org/privilege/message.write</privilege>
+ <privilege>http://tizen.org/privilege/notification</privilege>
+ <privilege>http://tizen.org/privilege/message.read</privilege>
+ <privilege>http://tizen.org/privilege/display</privilege>
+ </privileges>
</manifest>
projects / profile / wearable / apps / native / call-ui.git / commitdiff