virtual const ConfMemberList &getConferenceMemberList() const = 0;
};
- // Non-member functions
+ // Non-member functions //
bool isUnknownCaller(const ICallInfo &info);
}
{
}
- ActiveCall::~ActiveCall()
- {
- }
-
ActiveCallSRef ActiveCall::newInstance(CallManagerWRef cm, cm_call_data_h callData)
{
if (!cm) {
class ActiveCall final : public IActiveCall {
public:
- static ActiveCallSRef newInstance(CallManagerWRef cm, cm_call_data_h callData);
- virtual ~ActiveCall();
+ static ActiveCallSRef newInstance(CallManagerWRef cm,
+ cm_call_data_h callData);
- // IActiveCall
+ // 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 IConferenceCallInfoSCRef &confCallInfo) override final;
+ virtual ucl::Result split(
+ const IConferenceCallInfoSCRef &confCallInfo) override final;
private:
- friend class ucl::ReffedObj<ActiveCall>;
ActiveCall(CallManagerWRef cm, cm_call_data_h callData);
+ ~ActiveCall() = default;
ucl::Result prepare(cm_call_data_h callData);
CallManagerWRef m_cm;
CallInfoSRef m_callInfo;
bool m_isDialing;
+
+ friend class ucl::ReffedObj<ActiveCall>;
};
}
class BatteryStateSource final : public IIndicatorStateSource {
public:
static BatteryStateSourceSRef newInstance();
- virtual ~BatteryStateSource();
- // IIndicatorStateSource
+ // IIndicatorStateSource //
virtual IndicatorState getState() const override final;
- virtual void setStateChangeHandler(const NotiHandler &handler) override final;
+ virtual void setStateChangeHandler(
+ const NotiHandler &handler) override final;
private:
- friend class ucl::ReffedObj<BatteryStateSource>;
BatteryStateSource();
+ ~BatteryStateSource();
ucl::Result prepare();
private:
Bits m_bits;
NotiHandler m_handler;
+
+ friend class ucl::ReffedObj<BatteryStateSource>;
};
}
void setHeadsetConnectionChangeHandler(const NotiHandler &handler);
private:
- friend class ucl::ReffedObj<BluetoothManager>;
BluetoothManager();
- virtual ~BluetoothManager();
+ ~BluetoothManager();
ucl::Result prepare();
bool m_btAudioInitialized;
bool m_isHeadsetConnected;
+
+ friend class ucl::ReffedObj<BluetoothManager>;
};
}
class CallClient {
public:
static CallClientSRef newInstance();
- virtual ~CallClient();
cm_client_h getCmClient() const;
operator cm_client_h() const;
private:
- friend class ucl::ReffedObj<CallClient>;
CallClient();
+ ~CallClient();
+
ucl::Result prepare();
private:
cm_client_h m_client;
+
+ friend class ucl::ReffedObj<CallClient>;
};
}
{
}
- CallInfo::~CallInfo()
- {
- }
-
CallInfoSRef CallInfo::newInstance(CallClient &client,
cm_call_data_h callData,
ContactInfoProviderSRef callInfoProvider)
return m_confMemberList;
}
- // Non-member functions
+ // Non-member functions //
bool isUnknownCaller(const ICallInfo &info)
{
static CallInfoSRef newInstance(CallClient &client,
cm_call_data_h callData,
ContactInfoProviderSRef callInfoProvider);
- virtual ~CallInfo();
- // ICallInfo
+ // ICallInfo //
virtual unsigned int getCallId() const override final;
virtual const std::string &getPhoneNumber() const override final;
virtual const ConfMemberList &getConferenceMemberList() const override final;
private:
- friend class ucl::ReffedObj<CallInfo>;
CallInfo();
+ ~CallInfo() = default;
ucl::Result prepare(CallClient &client,
cm_call_data_h callData,
bool m_isVoiceMailNumber;
int m_confMemberCount;
ConfMemberList m_confMemberList;
+
+ friend class ucl::ReffedObj<CallInfo>;
};
}
{
}
- CallManager::~CallManager()
- {
- }
-
CallManagerSRef CallManager::newInstance(const CallClientSRef &callClient,
ICallManagerListenerWRef listener)
{
public:
static CallManagerSRef newInstance(const CallClientSRef &callClient,
ICallManagerListenerWRef listener);
- virtual ~CallManager();
CallClient &getCallClient();
SimSlot getSimSlot() const;
ucl::Result processOutgoingCall(const std::string &telNum);
ucl::Result processIncomingCall(SimSlot slot);
- // ICallManager
+ // ICallManager //
virtual IIncomingCallSRef getIncomingCall() override final;
virtual IActiveCallSRef getActiveCall() override final;
virtual CallMask getAvailableCalls() const override final;
private:
- friend class ucl::ReffedObj<CallManager>;
CallManager(ucl::IRefCountObj &rc, const CallClientSRef &callClient,
ICallManagerListenerWRef listener);
+ ~CallManager() = default;
ucl::Result prepare();
ucl::Result initCalls();
int m_confTypeCallReq;
bool m_blockCMEvents;
+
+ friend class ucl::ReffedObj<CallManager>;
};
}
{
}
- CallUI::~CallUI()
- {
- }
-
void CallUI::setListener(const ICallListenerWRef &listener)
{
m_listener = listener;
IndicatorProperty::VOICE_CONTROL, voiceControlStSrc),
"setStateSource() failed!");
- m_simSlotStSrc = makeShared<SimSlotStateSource>(
+ m_simSlotStSrc = SimSlotStateSource::newInstance(
m_callManager->getSimSlot(), getForwardedCallStatus());
FAIL_RETURN(m_indicatorStPrv->setStateSource(
IndicatorProperty::SIM_SLOT, m_simSlotStSrc),
"setStateSource() failed!");
- m_hdCallStSrc = makeShared<HdVoiceStateSource>(
- getHDVoiceStatus());
+ m_hdCallStSrc = HdVoiceStateSource::newInstance(getHDVoiceStatus());
FAIL_RETURN(m_indicatorStPrv->setStateSource(
IndicatorProperty::HD_VOICE, m_hdCallStSrc),
"setStateSource() failed!");
public ICallUI,
public ICallManagerListener {
public:
- virtual ~CallUI();
- // ICallUI
+ // ICallUI //
virtual void setListener(const ICallListenerWRef &listener) override final;
virtual ucl::Result processAppControl(app_control_h appControl) override final;
virtual ICallManagerSRef getCallManager() override final;
virtual IIndicatorStateProviderSRef getIndicatorStateProvider() override final;
- // ICallManagerListener
+ // ICallManagerListener //
virtual void onCallEvent(CallEventType type) override final;
virtual void onError(CallManagerErr err) override final;
private:
- friend class CallUIBuilder;
- friend class ucl::ReffedObj<CallUI>;
CallUI(ucl::IRefCountObj &rc);
+ ~CallUI() = default;
ucl::Result prepare();
HdVoiceStateSourceSRef m_hdCallStSrc;
IndicatorStateProviderSRef m_indicatorStPrv;
VoiceControlStateProviderSRef m_voiceControlPrv;
+
+ friend class CallUIBuilder;
+ friend class ucl::ReffedObj<CallUI>;
};
}
{
}
- ConferenceCallInfo::~ConferenceCallInfo()
- {
- }
-
ConferenceCallInfoSRef ConferenceCallInfo::newInstance(
cm_conf_call_data_t *confCallData,
ContactInfoProviderSRef callInfoProvider)
static ConferenceCallInfoSRef newInstance(
cm_conf_call_data_t *confCallData,
ContactInfoProviderSRef callInfoProvider);
- virtual ~ConferenceCallInfo();
- // IConferenceCallInfo
+ // IConferenceCallInfo //
virtual unsigned int getCallId() const override final;
virtual const std::string &getPhoneNumber() const override final;
virtual IContactInfoSCRef getContactInfo() const override final;
private:
- friend class ucl::ReffedObj<ConferenceCallInfo>;
ConferenceCallInfo();
+ ~ConferenceCallInfo() = default;
ucl::Result prepare(cm_conf_call_data_t *confCallData,
ContactInfoProviderSRef callInfoProvider);
unsigned int m_callId;
std::string m_phoneNum;
ContactInfoSRef m_contactInfo;
+
+ friend class ucl::ReffedObj<ConferenceCallInfo>;
};
}
class ConnectionStateSource final : public IIndicatorStateSource {
public:
static ConnectionStateSourceSRef newInstance();
- virtual ~ConnectionStateSource();
- // IIndicatorStateSource
+ // IIndicatorStateSource //
virtual IndicatorState getState() const override final;
virtual void setStateChangeHandler(const NotiHandler &handler) override final;
private:
- friend class ucl::ReffedObj<ConnectionStateSource>;
ConnectionStateSource();
+ ~ConnectionStateSource();
ucl::Result prepare();
private:
Bits m_bits;
NotiHandler m_handler;
+
+ friend class ucl::ReffedObj<ConnectionStateSource>;
};
}
{
}
- ContactInfo::~ContactInfo()
- {
- }
-
ContactInfoSRef ContactInfo::newInstance(int personId,
const std::string &name,
const std::string &imagePath,
const std::string &name,
const std::string &imagePath,
ContactNameSourceType type);
- virtual ~ContactInfo();
- // IContactInfo
+ // IContactInfo //
virtual const std::string &getName() const override final;
virtual const std::string &getImagePath() const override final;
virtual ContactNameSourceType getNameSourceType() const override final;
private:
- friend class ucl::ReffedObj<ContactInfo>;
ContactInfo(int personId,
const std::string &name,
const std::string &imagePath,
ContactNameSourceType type);
+ ~ContactInfo() = default;
private:
int m_personId;
std::string m_name;
std::string m_imagePath;
ContactNameSourceType m_nameSource;
+
+ friend class ucl::ReffedObj<ContactInfo>;
};
}
class ContactInfoProvider {
public:
static ContactInfoProviderSRef newInstance();
- virtual ~ContactInfoProvider();
ContactInfoSRef createContactInfo(int contactId);
private:
- friend class ucl::ReffedObj<ContactInfoProvider>;
ContactInfoProvider();
+ ~ContactInfoProvider();
ucl::Result prepare();
private:
bool m_isConnected;
+
+ friend class ucl::ReffedObj<ContactInfoProvider>;
};
}
{
}
- EndCall::~EndCall()
- {
- }
-
EndCallSRef EndCall::newInstance(CallManagerWRef cm, ICallInfoSCRef callInfo)
{
if (!cm) {
public:
static EndCallSRef newInstance(CallManagerWRef cm, ICallInfoSCRef callInfo);
- virtual ~EndCall();
-
- // IEndCall
+ // IEndCall //
virtual ICallInfoSCRef getInfo() const override final;
virtual ucl::Result callBack() override final;
virtual ucl::Result writeMessage() override final;
private:
- friend class ucl::ReffedObj<EndCall>;
EndCall(CallManagerWRef cm, ICallInfoSCRef callInfo);
+ ~EndCall() = default;
ucl::Result prepare();
CallManagerWRef m_cm;
ICallInfoSCRef m_callInfo;
bool m_callbackInProgress;
+
+ friend class ucl::ReffedObj<EndCall>;
};
}
m_bits.isEnable = isEnable;
}
- HdVoiceStateSource::~HdVoiceStateSource()
- {
- }
-
void HdVoiceStateSource::updateState(bool isEnable)
{
if (m_bits.isEnable != isEnable) {
}
}
+ HdVoiceStateSourceSRef HdVoiceStateSource::newInstance(bool isEnable)
+ {
+ return makeShared<HdVoiceStateSource>(isEnable);
+ }
+
IndicatorState HdVoiceStateSource::getState() const
{
return {m_bits.value};
class HdVoiceStateSource final : public IIndicatorStateSource {
public:
- HdVoiceStateSource(bool isEnable);
- virtual ~HdVoiceStateSource();
+ static HdVoiceStateSourceSRef newInstance(bool isEnable);
void updateState(bool isEnable);
- // IIndicatorStateSource
+ // IIndicatorStateSource //
virtual IndicatorState getState() const override final;
virtual void setStateChangeHandler(const NotiHandler &handler) override final;
+ private:
+ HdVoiceStateSource(bool isEnable);
+ ~HdVoiceStateSource() = default;
+
public:
union Bits {
struct {
private:
Bits m_bits;
NotiHandler m_handler;
+
+ friend class ucl::ReffedObj<HdVoiceStateSource>;
};
}
{
}
- HeldCall::~HeldCall()
- {
- }
-
HeldCallSRef HeldCall::newInstance(CallManagerWRef cm, cm_call_data_h callData)
{
if (!cm) {
class HeldCall final : public IHeldCall {
public:
- static HeldCallSRef newInstance(CallManagerWRef cm, cm_call_data_h callData);
- virtual ~HeldCall();
+ static HeldCallSRef newInstance(CallManagerWRef cm,
+ cm_call_data_h callData);
- // IHeldCall
+ // IHeldCall //
virtual ICallInfoSCRef getInfo() const override final;
virtual ucl::Result unhold() override final;
virtual ucl::Result joinWithActive() override final;
virtual ucl::Result swapWithActive() override final;
virtual ucl::Result end() override final;
- virtual ucl::Result split(const IConferenceCallInfoSCRef &confCallInfo) override final;
+ virtual ucl::Result split(
+ const IConferenceCallInfoSCRef &confCallInfo) override final;
private:
- friend class ucl::ReffedObj<HeldCall>;
HeldCall(CallManagerWRef cm, cm_call_data_h callData);
+ ~HeldCall() = default;
ucl::Result prepare(cm_call_data_h callData);
private:
CallManagerWRef m_cm;
CallInfoSRef m_callInfo;
+
+ friend class ucl::ReffedObj<HeldCall>;
};
}
{
}
- IncomingCall::~IncomingCall()
- {
- }
-
IncomingCallSRef IncomingCall::newInstance(CallManagerWRef cm, cm_call_data_h callData)
{
if (!cm) {
public:
static IncomingCallSRef newInstance(CallManagerWRef cm, cm_call_data_h callData);
- virtual ~IncomingCall();
-
- // IIncomingCall
+ // IIncomingCall //
virtual ICallInfoSCRef getInfo() const override final;
virtual IRejectMsgProviderSRef getRejectMsgProvider() const override final;
virtual ucl::Result stopAlert() override final;
private:
- friend class ucl::ReffedObj<IncomingCall>;
IncomingCall(CallManagerWRef cm, cm_call_data_h callData);
+ ~IncomingCall() = default;
ucl::Result prepare(cm_call_data_h callData);
private:
CallManagerWRef m_cm;
CallInfoSRef m_callInfo;
+
+ friend class ucl::ReffedObj<IncomingCall>;
};
}
{
}
- IndicatorStateProvider::~IndicatorStateProvider()
- {
- }
-
IndicatorStateProviderSRef IndicatorStateProvider::newInstance()
{
return makeShared<IndicatorStateProvider>();
public:
static IndicatorStateProviderSRef newInstance();
- virtual ~IndicatorStateProvider();
-
- virtual ucl::Result setStateSource(IndicatorProperty property,
+ ucl::Result setStateSource(IndicatorProperty property,
IIndicatorStateSourceSRef source);
- // IIndicatorStateProvider
+ // IIndicatorStateProvider //
virtual IndicatorState getState(IndicatorProperty property) const override final;
virtual void setListener(IIndicatorStateListenerWRef listener) override final;
private:
- friend class ucl::ReffedObj<IndicatorStateProvider>;
IndicatorStateProvider();
+ ~IndicatorStateProvider() = default;
void dispatchStateChanged(IndicatorProperty property) const;
private:
IIndicatorStateListenerWRef m_listener;
std::array<SourceHandlerSRef, STATE_COUNT> m_sources;
+
+ friend class ucl::ReffedObj<IndicatorStateProvider>;
};
}
class MsgClient {
public:
static MsgClientSRef newInstance();
- virtual ~MsgClient();
msg_handle_t getMsgHandle() const;
operator msg_handle_t() const;
private:
- friend class ucl::ReffedObj<MsgClient>;
MsgClient();
+ ~MsgClient();
ucl::Result prepare();
private:
msg_handle_t m_handle;
+
+ friend class ucl::ReffedObj<MsgClient>;
};
}
{
}
- RejectMsg::~RejectMsg()
- {
- }
-
RejectMsgSRef RejectMsg::newInstance(MsgClientWRef client, const TString &string)
{
return makeShared<RejectMsg>(client, string);
class RejectMsg : public IRejectMsg {
public:
static RejectMsgSRef newInstance(MsgClientWRef client, const ucl::TString &string);
- virtual ~RejectMsg();
-
ucl::Result send(const std::string &number, SimSlot slot);
- // IRejectMsg
+ // IRejectMsg //
std::string getText() const override final;
private:
- friend class ucl::ReffedObj<RejectMsg>;
RejectMsg(MsgClientWRef client, const ucl::TString &string);
+ ~RejectMsg() = default;
ucl::Result prepare();
private:
MsgClientWRef m_msgClient;
ucl::TString m_msg;
+
+ friend class ucl::ReffedObj<RejectMsg>;
};
}
{
}
- RejectMsgProvider::~RejectMsgProvider()
- {
- }
-
RejectMsgProviderSRef RejectMsgProvider::newInstance()
{
auto result = makeShared<RejectMsgProvider>();
class RejectMsgProvider : public IRejectMsgProvider {
public:
static RejectMsgProviderSRef newInstance();
- virtual ~RejectMsgProvider();
- // IRejectMsgProvider
+ // IRejectMsgProvider //
virtual RejectMsgList getMsgList() const override final;
virtual int getMsgCount() const override final;
private:
- friend class ucl::ReffedObj<RejectMsgProvider>;
RejectMsgProvider();
+ ~RejectMsgProvider() = default;
ucl::Result prepare();
IRejectMsgSRef getRejectMsgByIndex(int index) const;
private:
MsgClientSRef m_msgClient;
+
+ friend class ucl::ReffedObj<RejectMsgProvider>;
};
}
class RssiStateSource final : public IIndicatorStateSource {
public:
static RssiStateSourceSRef newInstance();
- virtual ~RssiStateSource();
- // IIndicatorStateSource
+ // IIndicatorStateSource //
virtual IndicatorState getState() const override final;
virtual void setStateChangeHandler(const NotiHandler &handler) override final;
private:
- friend class ucl::ReffedObj<RssiStateSource>;
RssiStateSource();
+ ~RssiStateSource();
ucl::Result prepare();
ucl::Result addSysStateCallbacks();
private:
Bits m_bits;
NotiHandler m_handler;
+
+ friend class ucl::ReffedObj<RssiStateSource>;
};
}
m_bits.isForwarded = isForwarded;
}
- SimSlotStateSource::~SimSlotStateSource()
+ SimSlotStateSourceSRef SimSlotStateSource::newInstance(SimSlot slot, bool isForwarded)
{
+ return makeShared<SimSlotStateSource>(slot, isForwarded);
}
void SimSlotStateSource::updateSimSlot(SimSlot slot, bool isForwarded)
class SimSlotStateSource final : public IIndicatorStateSource {
public:
- SimSlotStateSource(SimSlot slot, bool isForwarded);
- virtual ~SimSlotStateSource();
+ static SimSlotStateSourceSRef newInstance(SimSlot slot,
+ bool isForwarded);
void updateSimSlot(SimSlot slot, bool isForwarded);
- // IIndicatorStateSource
+ // IIndicatorStateSource //
virtual IndicatorState getState() const override final;
- virtual void setStateChangeHandler(const NotiHandler &handler) override final;
-
- public:
- union Bits {
- struct {
- uint8_t property : 4;
- uint8_t simSlot : 4;
- uint8_t isForwarded: 1;
- };
- uint64_t value;
-
- Bits();
- Bits(const IndicatorState &state);
+ virtual void setStateChangeHandler(
+ const NotiHandler &handler) override final;
+
+ private:
+ SimSlotStateSource(SimSlot slot, bool isForwarded);
+ ~SimSlotStateSource() = default;
+
+ public:
+ union Bits {
+ struct {
+ uint8_t property : 4;
+ uint8_t simSlot : 4;
+ uint8_t isForwarded: 1;
};
+ uint64_t value;
+
+ Bits();
+ Bits(const IndicatorState &state);
+ };
+
+ private:
+ Bits m_bits;
+ NotiHandler m_handler;
- private:
- Bits m_bits;
- NotiHandler m_handler;
+ friend class ucl::ReffedObj<SimSlotStateSource>;
};
}
public ISoundManager {
public:
static SoundManagerSRef newInstance(const CallClientSRef &client);
- virtual ~SoundManager();
- // ISoundManager
+ // ISoundManager //
virtual ucl::Result setSpeakerState(bool isEnable) override final;
virtual ucl::Result setBluetoothState(bool isEnable) override final;
const NotiHandler &handler) override final;
private:
- friend class ucl::ReffedObj<SoundManager>;
SoundManager(ucl::IRefCountObj &rc, const CallClientSRef &client);
+ ~SoundManager();
ucl::Result prepare();
ucl::Result registerCallbacks();
ucl::Event<NotiHandler> m_volumeLevelEvent;
ucl::Event<NotiHandler> m_btVoiceDeviceConnEvent;
int m_deviceVolumeCbId;
+
+ friend class ucl::ReffedObj<SoundManager>;
};
}
class VoiceControlStateProvider final {
public:
static VoiceControlStateProviderSRef newInstance();
- virtual ~VoiceControlStateProvider();
bool getState() const;
void addStateChangeHandler(const NotiHandler &handler);
void removeStateChangeHandler(const NotiHandler &handler);
private:
- friend class ucl::ReffedObj<VoiceControlStateProvider>;
VoiceControlStateProvider();
+ ~VoiceControlStateProvider();
ucl::Result prepare();
private:
bool m_enableState;
ucl::Event<NotiHandler> m_event;
+
+ friend class ucl::ReffedObj<VoiceControlStateProvider>;
};
}
public:
static VoiceControlStateSourceSRef newInstance(
const VoiceControlStateProviderSRef &provider);
- virtual ~VoiceControlStateSource();
- // IIndicatorStateSource
+ // IIndicatorStateSource //
virtual IndicatorState getState() const override final;
virtual void setStateChangeHandler(
const NotiHandler &handler) override final;
private:
- friend class ucl::ReffedObj<VoiceControlStateSource>;
VoiceControlStateSource(ucl::IRefCountObj &rc,
const VoiceControlStateProviderSRef &provider);
+ ~VoiceControlStateSource();
ucl::Result prepare();
Bits m_bits;
NotiHandler m_handler;
VoiceControlStateProviderSRef m_vcProvider;
+
+ friend class ucl::ReffedObj<VoiceControlStateSource>;
};
}
template <class ...ARGS>
ucl::NaviItem insertBefore(ARGS &&...args);
- // ucl::IDisposable
+ // ucl::IDisposable //
virtual void dispose() override;
virtual bool isDisposed() const final override;
protected:
Page(ucl::IRefCountObj &rc, const ucl::NaviframeSRef &navi,
const ExitRequestHandler &onExitRequest);
- virtual ~Page();
+ ~Page();
template <class ON_PREPARE>
ucl::Result prepare(ON_PREPARE &&onPrepare);
PageSRef m_selfRef;
};
- // Non-member functions
+ // Non-member functions //
bool isLast(const Page &page);
}
return (m_navi->getBottomItem() == m_item);
}
- // Non-member functions
+ // Non-member functions //
inline bool isLast(const Page &page)
{
{
}
- AcceptDialog::Builder::~Builder()
- {
- }
-
AcceptDialog::Builder &
AcceptDialog::Builder::setHandler(EventHandler handler)
{
class Builder {
public:
Builder();
- ~Builder();
Builder &setHandler(EventHandler handler);
AcceptDialogWRef build(ucl::ElmWidget &parent) const;
private:
};
public:
- virtual ~AcceptDialog();
-
void dismiss();
- // ucl::IDisposable
+ // ucl::IDisposable //
virtual void dispose() final override;
virtual bool isDisposed() const final override;
private:
- friend class ucl::ReffedObj<AcceptDialog>;
- AcceptDialog(ucl::IRefCountObj &rc,
- const EventHandler &handler);
+ AcceptDialog(ucl::IRefCountObj &rc, const EventHandler &handler);
+ ~AcceptDialog();
ucl::Result prepare(ucl::ElmWidget &parent);
EventHandler m_handler;
AcceptDialogSRef m_selfRef;
bool m_isDismissed;
+
+ friend class ucl::ReffedObj<AcceptDialog>;
};
}
using namespace ucl;
- // AcceptRejectPresenter::Builder
+ // AcceptRejectPresenter::Builder //
AcceptRejectPresenter::Builder::Builder():
m_callMask(CALL_FLAG_NONE)
{
}
- AcceptRejectPresenter::Builder::~Builder()
- {
- }
-
AcceptRejectPresenter::Builder &
AcceptRejectPresenter::Builder::setIncomingCall(
const IIncomingCallSRef &call)
return result;
}
- // AcceptRejectPresenter
+ // AcceptRejectPresenter //
AcceptRejectPresenter::AcceptRejectPresenter(IRefCountObj &rc,
const IIncomingCallSRef &call,
AcceptButtonType::SIMPLE);
}
- // Screen Reader
ElmWidget *AcceptRejectPresenter::getAcceptAo()
{
return m_widget->getAcceptAo();
class Builder {
public:
Builder();
- ~Builder();
Builder &setIncomingCall(const IIncomingCallSRef &call);
Builder &setSoundManager(const ISoundManagerSRef &sm);
Builder &setAvailableCallsFlag(CallMask calls);
};
public:
- virtual ~AcceptRejectPresenter();
-
ucl::Widget &getWidget();
-
void update(CallMask calls);
ucl::ElmWidget *getAcceptAo();
ucl::ElmWidget *getRejectAo();
private:
- friend class ucl::ReffedObj<AcceptRejectPresenter>;
AcceptRejectPresenter(ucl::IRefCountObj &rc,
const IIncomingCallSRef &call,
CallMask calls,
const ISoundManagerSRef &sm);
+ ~AcceptRejectPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent,
ucl::ElmWidget &parentWidget);
void onRejectEvent();
void onBTHeadsetConnectionChanged();
- // GuiPresenter
+ // GuiPresenter //
+
virtual void onActivate() final override;
virtual void onDeactivate() final override;
IIncomingCallSRef m_call;
CallMask m_callMask;
ISoundManagerSRef m_sm;
+
+ friend class ucl::ReffedObj<AcceptRejectPresenter>;
};
}
m_muteBtn->emit(impl::SIGNAL_TURN_OFF);
}
- // Screen Reader
ElmWidget *AccessoryPresenter::getVolumBtn()
{
return m_volumeBtn.get();
};
public:
- virtual ~AccessoryPresenter();
-
ucl::Widget &getWidget();
void hideVolumeControls();
ucl::Result update(const ICallManagerSRef &cm);
- // Screen Reader
ucl::ElmWidget *getVolumBtn();
ucl::ElmWidget *getBluetoothBtn();
ucl::ElmWidget *getMuteBtn();
END
};
private:
- friend class ucl::ReffedObj<AccessoryPresenter>;
AccessoryPresenter(ucl::IRefCountObj &rc, const ISoundManagerSRef &sm,
const NotiHandler &handler);
+ ~AccessoryPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent,
ucl::ElmWidget &parentWidget, const ICallManagerSRef &cm);
ucl::Result setActiveCallCompomnents();
ucl::Result setEndCallCompomnents(const ICallManagerSRef &cm);
- // Screen Reader
void registerVolumeControlAo();
void onVolumeControlScreenReaderReadStart(ucl::Widget &widget, void *eventInfo);
NotiHandler m_exitHandler;
bool m_isVcShowOnRotaryEvent;
+
+ friend class ucl::ReffedObj<AccessoryPresenter>;
};
}
{
}
- AtspiHighlightHelper::~AtspiHighlightHelper()
- {
- }
-
Result AtspiHighlightHelper::prepare(GuiPresenter &parent,
ElmWidget &rootWidget)
{
const Elm_Atspi_Gesture_Info &info);
private:
- friend class ucl::ReffedObj<AtspiHighlightHelper>;
AtspiHighlightHelper(ucl::IRefCountObj &rc);
- virtual ~AtspiHighlightHelper();
+ ~AtspiHighlightHelper() = default;
ucl::Result prepare(GuiPresenter &parent, ucl::ElmWidget &rootWidget);
private:
RelationEventHandler m_relationEventHandler;
GestureEventHandler m_gestureEventHandler;
+
+ friend class ucl::ReffedObj<AtspiHighlightHelper>;
};
}
{
}
- CallInfoPresenter::Builder::~Builder()
- {
- }
-
CallInfoPresenter::Builder &
CallInfoPresenter::Builder::setCallManager(const ICallManagerSRef &cm)
{
return RES_OK;
}
- // Screen Reader
ElmWidget *CallInfoPresenter::getMainTxtAo()
{
return m_mainTxtAO.get();
class Builder {
public:
Builder();
- virtual ~Builder();
Builder &setCallManager(const ICallManagerSRef &cm);
Builder &setMode(CallMode mode);
Builder &setParentWidget(const ucl::ElmWidgetSRef &parentWidget);
};
public:
- virtual ~CallInfoPresenter();
-
ucl::Widget &getWidget();
CallMode getMode() const;
ucl::Result update(CallMode mode, const ICallManagerSRef &cm);
- // Screen Reader
ucl::ElmWidget *getStatusTxtAo();
ucl::ElmWidget *getMainTxtAo();
ucl::ElmWidget *getSubTxtAo();
private:
- friend class ucl::ReffedObj<CallInfoPresenter>;
CallInfoPresenter(ucl::IRefCountObj &rc,
const ICallManagerSRef &cm,
CallMode mode);
+ ~CallInfoPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent,
ucl::ElmWidget &parentWidget);
void unsetLanguageChangeCallback();
void onLanguageChanged(ucl::Widget &widget, void *eventInfo);
- // Screen Reader
ucl::Result setMainTxtAccessObject(const std::string &text);
ucl::Result setSubTxtAccessObject(const std::string &text);
bool m_isSubTxtEnable;
bool m_needModifyCallStatus;
- // Screen Reader
ucl::ElmWidgetSRef m_statusAO;
ucl::ElmWidgetSRef m_mainTxtAO;
ucl::ElmWidgetSRef m_subTxtAO;
+
+ friend class ucl::ReffedObj<CallInfoPresenter>;
};
}
{
}
- CallStatusPresenter::Builder::~Builder()
- {
- }
-
CallStatusPresenter::Builder &
CallStatusPresenter::Builder::setMode(CallMode mode)
{
return RES_OK;
}
- // Screen Reader
Result CallStatusPresenter::createStatusTxtAo()
{
if (!m_statusTxtAo) {
class Builder {
public:
Builder();
- virtual ~Builder();
Builder &setMode(CallMode mode);
Builder &setCallInfo(const ICallInfoWCRef &info);
Builder &setCallHoldState(bool isOnHold);
bool m_isOnHold;
};
public:
- virtual ~CallStatusPresenter();
-
- // Screen Reader
ucl::ElmWidget *getStatusTextAo();
private:
- friend class ucl::ReffedObj<CallStatusPresenter>;
CallStatusPresenter(ucl::IRefCountObj &rc,
const ucl::LayoutSRef &layout,
CallMode mode,
const ICallInfoWCRef &info,
bool isOnHold);
+ ~CallStatusPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent);
void unsetLanguageChangeCallback();
void onLanguageChanged(ucl::Widget &widget, void *eventInfo);
- // Screen Reader
ucl::Result createStatusTxtAo();
private:
struct tm m_duration;
int m_blinkCount;
- // Screen Reader
ucl::ElmWidgetSRef m_statusTxtAo;
+
+ friend class ucl::ReffedObj<CallStatusPresenter>;
};
}
using namespace ucl;
- // DeviceStatePresenter::Builder
+ // DeviceStatePresenter::Builder //
DeviceStatePresenter::Builder::Builder():
m_state(DisplayState::UNDEFINED),
return result;
}
- // DeviceStatePresenter
+ // DeviceStatePresenter //
DeviceStatePresenter::DeviceStatePresenter(const ucl::WindowSRef &window):
m_window(window),
ucl::Result setCpuLockState(bool lockState);
private:
- friend class ucl::ReffedObj<DeviceStatePresenter>;
DeviceStatePresenter(const ucl::WindowSRef &window);
~DeviceStatePresenter() = default;
ucl::WindowSRef m_window;
DisplayMode m_mode;
bool m_lockState;
+
+ friend class ucl::ReffedObj<DeviceStatePresenter>;
};
}
{
}
- IndicatorPresenter::Builder::~Builder()
- {
- }
-
IndicatorPresenter::Builder &
IndicatorPresenter::Builder::setIndicatorStateProvider(
const IIndicatorStateProviderSRef &provider)
class Builder {
public:
Builder();
- ~Builder();
Builder &setIndicatorStateProvider(
const IIndicatorStateProviderSRef &provider);
Builder &setParentWidget(const ucl::ElmWidgetSRef
};
public:
- virtual ~IndicatorPresenter();
-
ucl::Widget &getWidget();
void udapteIncomingCallMode(bool isIncomingCallMode);
private:
- friend class ucl::ReffedObj<IndicatorPresenter>;
IndicatorPresenter(ucl::IRefCountObj &rc,
const IIndicatorStateProviderSRef &provider);
+ ~IndicatorPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent, ucl::ElmWidget &parentWidget);
void updateCentralIcon();
- // IIndicatorStateListener
+ // IIndicatorStateListener //
virtual void onStateChanged(IndicatorProperty property) override final;
ucl::LayoutSRef m_voiceControlLayout;
IIndicatorStateProviderSRef m_provider;
bool m_isIncomingCallMode;
+
+ friend class ucl::ReffedObj<IndicatorPresenter>;
};
ucl::EdjeSignal getConnectionSignal(ConnectionType type);
using namespace ucl;
- // MoreOptionsPresenter::Builder
+ // MoreOptionsPresenter::Builder //
MoreOptionsPresenter::Builder::Builder()
{
return result;
}
- // MoreOptionsPresenter
+ // MoreOptionsPresenter //
MoreOptionsPresenter::MoreOptionsPresenter(IRefCountObj &rc,
const ICallManagerSRef &cm,
show(widget);
}
- // Screen Reader
Result MoreOptionsPresenter::createAtspiHighlightHelper()
{
DLOG("ENTER");
ucl::Widget &getWidget();
void update();
- // Screen Reader
ucl::ElmWidget *getCueAo();
private:
- friend class ucl::ReffedObj<MoreOptionsPresenter>;
MoreOptionsPresenter(ucl::IRefCountObj &rc,
const ICallManagerSRef &cm,
const ISoundManagerSRef &sm,
const ucl::NaviframeSRef &navi);
- virtual ~MoreOptionsPresenter();
+ ~MoreOptionsPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent,
ucl::ElmWidget &parentWidget);
void onPageExitRequest(Page &page);
- // Screen Reader
ucl::Result createAccessObjects();
ucl::Result createCueAo();
ucl::Result createStatusTxtAo();
Ecore_Timer *m_timer;
struct tm m_duration;
- // Screen Reader
AtspiHighlightHelperSRef m_atspiHelper;
ucl::ElmWidgetSRef m_fakeAo;
ucl::ElmWidgetSRef m_cueAo;
ucl::ElmWidgetSRef m_statusTxtAo;
+
+ friend class ucl::ReffedObj<MoreOptionsPresenter>;
};
}
MotionSensorPresenterSRef build(const NotiHandler handler) const;
};
private:
- friend class ucl::ReffedObj<MotionSensorPresenter>;
MotionSensorPresenter(const NotiHandler &handler);
- virtual ~MotionSensorPresenter();
+ ~MotionSensorPresenter();
ucl::Result prepare();
private:
NotiHandler m_handler;
gesture_h m_gesture;
+
+ friend class ucl::ReffedObj<MotionSensorPresenter>;
};
}
{
}
- RejectMsgPresenter::Builder::~Builder()
- {
- }
-
RejectMsgPresenter::Builder &
RejectMsgPresenter::Builder::setProvider(
const IRejectMsgProviderSRef &provider)
}
}
- // Screen Reader
Elm_Interface_Atspi_Accessible *RejectMsgPresenter::getFirstAo()
{
return (m_genlist) ?
class Builder {
public:
Builder();
- virtual ~Builder();
Builder &setProvider(const IRejectMsgProviderSRef &provider);
Builder &setStateHandler(const StateHandler &handler);
Builder &setSelectHandler(const SelectHandler &handler);
};
public:
- virtual ~RejectMsgPresenter();
-
ucl::Widget &getWidget();
State getState();
class RejectMsgItem;
private:
- friend class ucl::ReffedObj<RejectMsgPresenter>;
RejectMsgPresenter(ucl::IRefCountObj &rc,
const IRejectMsgProviderSRef &provider,
const StateHandler &stateHandler,
const SelectHandler &selectHandler);
+ ~RejectMsgPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent,
ucl::ElmWidget &parentWidget);
void unsetLanguageChangeCallback();
void onLanguageChanged(ucl::Widget &widget, void *eventInfo);
- // Screen Reader
ucl::Result createAtspiHighlightHelper();
void registerGenlistAtspiGestureCallbacks();
Elm_Interface_Atspi_Accessible *getFirstAo();
Elm_Interface_Atspi_Accessible *ao,
Elm_Atspi_Relation_Type flowRelation);
- // Presenter
+ // GuiPresenter //
virtual void onActivate() final override;
virtual void onDeactivate() final override;
SelectHandler m_selectHandler;
State m_state;
- // Screen Reader
AtspiHighlightHelperSRef m_atspiHelper;
+
+ friend class ucl::ReffedObj<RejectMsgPresenter>;
};
}
{
}
- KeypadPage::Builder::~Builder()
- {
- }
-
KeypadPage::Builder &KeypadPage::Builder::setNaviframe(
const NaviframeSRef &navi)
{
return result;
}
- // KeypadPage
+ // KeypadPage //
KeypadPage::KeypadPage(IRefCountObj &rc,
const ISoundManagerSRef &sm,
KeypadPage::onVolumeLevelChanged, asWeak(*this)));
}
- // Screen Reader
Result KeypadPage::createAtspiHighlightHelper()
{
m_atspiHelper = AtspiHighlightHelper::newInstance(*this, getWindow());
class Builder {
public:
Builder();
- ~Builder();
Builder &setNaviframe(const ucl::NaviframeSRef &navi);
Builder &setSoundManager(const ISoundManagerSRef &sm);
KeypadPageSRef build(const ExitRequestHandler onExitRequest) const;
};
private:
- friend class ucl::ReffedObj<KeypadPage>;
KeypadPage(ucl::IRefCountObj &rc,
const ISoundManagerSRef &sm,
const ucl::NaviframeSRef &navi,
const ExitRequestHandler onExitRequest);
- virtual ~KeypadPage();
+ ~KeypadPage();
ucl::Result doPrepare(ucl::NaviItem &item);
void registerCallbacks();
void unregisterCallbacks();
- // Screen Reader
ucl::Result createAtspiHighlightHelper();
Elm_Interface_Atspi_Accessible *onAtspiHighlight(
Elm_Interface_Atspi_Accessible *ao,
ucl::Widget &widget,
void *eventInfo);
-
- // Page
+ // Page //
virtual void onBackKey() override final;
Ecore_Timer *m_vcTimer;
AudioStateType m_audioState;
- // Screen Reader
AtspiHighlightHelperSRef m_atspiHelper;
+
+ friend class ucl::ReffedObj<KeypadPage>;
};
}
using namespace ucl;
- // MainPage::Builder
+ // MainPage::Builder //
MainPage::Builder::Builder()
{
return result;
}
- // MainPage
+ // MainPage //
MainPage::MainPage(IRefCountObj &rc,
const NaviframeSRef &navi,
{
}
- MainPage::~MainPage()
- {
- }
-
Result MainPage::doPrepare(NaviItem &item)
{
m_cm = m_call->getCallManager();
}
}
- // Screen Reader
Result MainPage::createRejectMsgCueAo()
{
m_rmCueAo = utils::createAccessObjectFromLyPart(*m_widget,
};
private:
- friend class ucl::ReffedObj<MainPage>;
MainPage(ucl::IRefCountObj &rc,
const ucl::NaviframeSRef &navi,
const ExitRequestHandler handler,
const ICallUISRef &call);
- virtual ~MainPage();
+ ~MainPage() = default;
ucl::Result doPrepare(ucl::NaviItem &item);
void onExitAppRequest();
- // Screen Reader
ucl::Result createRejectMsgCueAo();
ucl::Result createAtspiHighlightHelper();
void registerIncomingCallModeAo();
Elm_Interface_Atspi_Accessible *widget,
Elm_Atspi_Gesture_Type gestureType);
- // Page
+ // Page //
virtual void onBackKey() final override;
- // ICallListener
+ // ICallListener //
virtual void onCallEvent(CallEventType type) final override;
virtual void onError(CallErr err) final override;
Ecore_Timer *m_ecTimer;
bool m_ecTimerBtnReq;
- // Screen Reader
ucl::ElmWidgetSRef m_rmCueAo;
AtspiHighlightHelperSRef m_atspiHelper;
+
+ friend class ucl::ReffedObj<MainPage>;
};
}
setRejectUnpressedTransitions();
}
- // Screen Reader
ElmWidget *AcceptRejectWidget::getAcceptAo()
{
return m_accAo.get();
};
public:
- ~AcceptRejectWidget();
+ virtual ~AcceptRejectWidget();
void startBezelCueAnimation();
void reset();
void deactivateRotary();
void setAcceptBtnType(AcceptButtonType type);
- // Screen Reader
ucl::ElmWidget *getAcceptAo();
ucl::ElmWidget *getRejectAo();
private:
- friend class ucl::ReffedObj<AcceptRejectWidget>;
AcceptRejectWidget(ucl::IRefCountObj &rc,
const ucl::LayoutSRef &layout,
const NotiHandler &acceptHandler,
void setAcceptUnpressedState();
void setRejectUnpressedState();
- // Screen Reader
ucl::Result registerAccessObjects(
ucl::ElmWidget &widget);
AcceptButtonType m_acceptBtnType;
- // Screen Reader
ucl::ElmWidgetSRef m_accAo;
ucl::ElmWidgetSRef m_rejAo;
+
+ friend class ucl::ReffedObj<AcceptRejectWidget>;
};
}
prepare(maxValue, curValue);
}
- Slider::~Slider()
- {
- }
-
void Slider::prepare(int maxValue, int curValue)
{
m_layout->setIsOwner(false);
};
public:
+ virtual ~Slider() = default;
+
virtual void setValue(int value);
virtual void setMaxValue(int maxValue);
protected:
- friend class ucl::ReffedObj<Slider>;
Slider(ucl::IRefCountObj &rc,
const ucl::LayoutSRef &layout,
int maxValue,
int curValue);
- virtual ~Slider();
private:
void prepare(int maxValue, int curValue);
ucl::Layout m_circleLy;
Eext_Circle_Surface *m_circleSurf;
ucl::ElmWidget m_slider;
+
+ friend class ucl::ReffedObj<Slider>;
};
}
prepare(info, curValue);
}
- VolumeControl::~VolumeControl()
- {
- }
-
void VolumeControl::prepare(const TString &info, int curValue)
{
m_layout->addEventHandler(WidgetEvent::SHOW, WEAK_DELEGATE(
}
}
- // Screen Reader
ElmWidget *VolumeControl::getDecreaseBtn()
{
return &m_decreaseBtn;
};
public:
+ virtual ~VolumeControl() = default;
+
void setInfoText(const ucl::TString &info);
void setDecreaseBtnEnable(bool isEnable);
void setIncreaseBtnEnable(bool isEnable);
void setEventHandler(const EventHandler &handler);
- // Slider
-
- virtual void setValue(int value) override final;
-
- // Screen Reader
ucl::ElmWidget *getDecreaseBtn();
ucl::ElmWidget *getIncreaseBtn();
ucl::ElmWidget *getValueTxtAo();
+ // Slider //
+
+ virtual void setValue(int value) override final;
+
private:
- friend class ucl::ReffedObj<VolumeControl>;
VolumeControl(ucl::IRefCountObj &rc,
const ucl::LayoutSRef &layout,
const ucl::TString &info,
int curValue,
const EventHandler &handler);
- virtual ~VolumeControl();
-
void prepare(const ucl::TString &info, int curValue);
void onDecreaseBtnClickedCb(ucl::Widget &widget, void *eventInfo);
void onWidgetShowCb(Widget &widget, void *eventInfo);
void onWidgetHideCb(Widget &widget, void *eventInfo);
- // Screen Reader
void registerAccessObjectInformation();
private:
ucl::StyledWidget m_increaseBtn;
EventHandler m_handler;
- // Screen Reader
ucl::ElmWidgetSRef m_valueTxtAo;
+
+ friend class ucl::ReffedObj<VolumeControl>;
};
}
projects / profile / wearable / apps / native / call-ui.git / commitdiff