--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/phoneapp/phoneuiqtviewadapter/src/phoneuiqtviewadapter.cpp Fri Mar 19 09:28:42 2010 +0200
@@ -0,0 +1,997 @@
+/*!
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Phone UI's symbian adapter for Qt view.
+*
+*/
+
+#include "phoneuiqtviewadapter.h"
+#include "phoneuiqtviewif.h"
+#include "phonebubblewrapper.h"
+#include "tphonecmdparaminteger.h"
+#include "tphonecmdparamboolean.h"
+#include "tphonecmdparamaudioavailability.h"
+#include "tphonecmdparamaudiooutput.h"
+#include "tphonecmdparamcallstatedata.h"
+#include "tphonecmdparamcallheaderdata.h"
+#include "tphonecmdparamemergencycallheaderdata.h"
+#include "tphonecmdparamstring.h"
+#include "cphonepubsubproxy.h"
+#include "pevirtualengine.h"
+#include "cphonepubsubproxy.h"
+#include "cphoneringingtonecontroller.h"
+#include "phoneresourceadapter.h"
+#include "phoneui.hrh"
+#include "cphonemediatorfactory.h"
+#include "phoneuiqtbuttonscontroller.h"
+#include "phoneconstants.h"
+#include "phonenotecontroller.h"
+#include "telephonyservice.h"
+#include "phoneuicommandcontroller.h"
+#include <uikoninternalpskeys.h>
+#include <bubblemanagerif.h>
+#include <hbaction.h>
+#include <QtDebug>
+#include <pevirtualengine.h>
+#include <xqservicerequest.h>
+#include <QtGlobal>
+#include <xqserviceutil.h>
+#include <hbinstance.h>
+#include <QKeyEvent>
+
+//CONSTANTS
+static const int PHONE_CALL_NOT_FOUND = -1;
+
+PhoneUIQtViewAdapter::PhoneUIQtViewAdapter (PhoneUIQtViewIF &view, QObject *parent) :
+ QObject (parent), m_view (view), m_idleUid(-1), m_dialpadAboutToClose(false)
+{
+ m_bubbleWrapper = new PhoneBubbleWrapper(m_view.bubbleManager (), this);
+ m_noteController = new PhoneNoteController(this);
+ m_uiCommandController = new PhoneUiCommandController(view, this);
+
+ TRAPD( error, m_ringingtonecontroller = CPhoneRingingToneController::NewL () );
+ qt_symbian_throwIfError(error);
+ m_resourceAdapter = PhoneResourceAdapter::Instance(this);
+
+ // display initial toolbar to make client area size correct
+ TPhoneCmdParamInteger intParam;
+ intParam.SetInteger(m_resourceAdapter->defaultToolbarResourceId());
+ setToolbarButtons(&intParam);
+
+ m_telephonyService = new TelephonyService (this, this);
+}
+
+PhoneUIQtViewAdapter::~PhoneUIQtViewAdapter ()
+{
+ delete m_ringingtonecontroller;
+}
+
+void PhoneUIQtViewAdapter::ExecuteCommandL (TPhoneViewCommandId aCmdId)
+{
+ switch (aCmdId) {
+ case EPhoneAppShutDown:
+ {
+ m_view.shutdownPhoneApp();
+ }
+ break;
+
+ case EPhoneViewSetIdleTopApplication:
+ {
+ TPhoneCmdParamInteger uidParam;
+ uidParam.SetInteger (idleAppUid());
+ setTopApplication (&uidParam);
+ }
+ break;
+
+ case EPhoneViewMuteRingToneOnAnswer:
+ m_ringingtonecontroller->MuteRingingToneOnAnswer();
+ break;
+
+ case EPhoneViewStopRingTone:
+ m_ringingtonecontroller->StopPlaying();
+ break;
+
+ case EPhoneViewMuteRingTone:
+ m_ringingtonecontroller->MuteRingingTone();
+ break;
+
+ case EPhoneViewBeginUpdate:
+ m_bubbleWrapper->bubbleManager ().startChanges ();
+ break;
+
+ case EPhoneViewEndUpdate:
+ m_bubbleWrapper->bubbleManager ().endChanges ();
+ break;
+
+ case EPhoneViewHideNaviPaneAudioVolume:
+ m_view.removeVolumeSlider ();
+ break;
+
+ case EPhoneViewOpenDialer:
+ openDialpad();
+ break;
+
+ case EPhoneViewRemoveConferenceBubble:
+ removeConferenceBubble();
+ break;
+
+ case EPhoneViewSendToBackground:
+ case EPhoneViewBringIdleToForeground:
+ XQServiceUtil::toBackground(true);
+ break;
+ case EPhoneViewRemoveAllCallHeaders:
+ removeAllCallHeaders();
+ break;
+ case EPhoneViewRemoveNumberEntry:
+ case EPhoneViewClearNumberEntryContent: // Fall through
+ removeDialpad();
+ break;
+ case EPhoneViewAddToConference:
+ addToConference();
+ break;
+ case EPhoneViewRemoveDtmfNote:
+ m_noteController->removeDtmfNote();
+ break;
+ case EPhoneViewRemoveNote:
+ m_noteController->removeNote();
+ break;
+ case EPhoneViewRemoveQuery:
+ m_noteController->removeQuery();
+ break;
+ case EPhoneViewRemovePhoneDialogs:
+ m_noteController->removeNote();
+ m_noteController->removeQuery();
+ break;
+ case EPhoneViewRemoveGlobalNote:
+ case EPhoneViewRemoveGlobalWaitNote:
+ m_noteController->removeGlobalWaitNote();
+ break;
+
+ default:
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId );
+}
+
+void PhoneUIQtViewAdapter::ExecuteCommandL (TPhoneViewCommandId aCmdId, TInt aCallId)
+{
+ switch (aCmdId) {
+ case EPhoneViewRemoveCallHeader:
+ {
+ m_bubbleWrapper->bubbleManager().startChanges();
+ int bubble = m_bubbleWrapper->bubbles().value(aCallId);
+ m_view.clearBubbleCommands(bubble);
+ m_view.removeExpandAction(bubble);
+ m_bubbleWrapper->removeCallHeader (aCallId);
+ m_bubbleWrapper->bubbleManager().endChanges();
+ }
+ break;
+ case EPhoneViewRemoveFromConference:
+ removeCallFromConference(aCallId);
+ break;
+ case EPhoneViewPrivateFromConference:
+ setPrivateFromConference(aCallId);
+ break;
+ default:
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId, aCallId );
+}
+
+void PhoneUIQtViewAdapter::ExecuteCommandL (TPhoneViewCommandId aCmdId, TPhoneCommandParam* aCommandParam)
+{
+ switch (aCmdId) {
+ case EPhoneViewSetTopApplication:
+ setTopApplication (aCommandParam);
+ break;
+ case EPhoneViewPlayRingTone:
+ m_ringingtonecontroller->PlayRingToneL( aCommandParam );
+ break;
+ case EPhoneViewSetTouchPaneButtons:
+ setTouchButtons (aCommandParam);
+ setExpandActions();
+ break;
+ case EPhoneViewUpdateCba:
+ setToolbarButtons (aCommandParam);
+ break;
+ case EPhoneViewSetHoldFlag:
+ setCallHoldFlag (aCommandParam);
+ break;
+ case EPhoneViewGetHoldFlag:
+ callHoldFlag (aCommandParam);
+ break;
+ case EPhoneViewSetNaviPaneAudioVolume:
+ setAudioVolumeSliderValue (aCommandParam);
+ break;
+ case EPhoneViewActivateMuteUIChanges:
+ setMuteIndication(aCommandParam);
+ break;
+ case EPhoneViewGetCountOfActiveCalls:
+ activeCallCount(aCommandParam);
+ break;
+ case EPhoneViewActivateAudioPathUIChanges:
+ setAudioPath(aCommandParam);
+ break;
+ case EPhoneViewGetExpandedBubbleCallId:
+ expandedBubbleCallId(aCommandParam);
+ break;
+ case EPhoneViewGetIsConference:
+ isConference(aCommandParam);
+ break;
+ case EPhoneViewBringAppToForeground:
+ bringToForeground();
+ break;
+ case EPhoneViewShowGlobalNote:
+ showGlobalNote(aCommandParam);
+ break;
+ case EPhoneViewSetNumberEntryVisible:
+ setDialpadVisibility(aCommandParam);
+ break;
+ case EPhoneViewGetNumberEntryCount:
+ getDialpadStringLength(aCommandParam);
+ break;
+ case EPhoneViewGetNumberFromEntry:
+ getNumberFromDialpad(aCommandParam);
+ break;
+ case EPhoneViewShowNote:
+ showNote(aCommandParam);
+ break;
+ case EPhoneViewShowQuery:
+ m_noteController->showQuery(aCommandParam);
+ break;
+ default:
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId, *aCommandParam );
+}
+
+void PhoneUIQtViewAdapter::ExecuteCommandL (TPhoneViewCommandId aCmdId, TInt aCallId,
+ TPhoneCommandParam *aCommandParam)
+{
+ switch (aCmdId) {
+ case EPhoneViewCreateCallHeader:
+ createCallHeader (aCallId, aCommandParam);
+ break;
+ case EPhoneViewCreateEmergencyCallHeader:
+ createEmergencyCallHeader (aCallId, aCommandParam);
+ break;
+ case EPhoneViewUpdateBubble:
+ updateCallHeaderState (aCallId, aCommandParam);
+ setExpandActions();
+ break;
+ case EPhoneViewUpdateCallHeaderRemoteInfoData:
+ updateCallHeaderRemoteInfo (aCallId, aCommandParam);
+ break;
+ case EPhoneViewUpdateCallHeaderRemoteInfoDataAndLabel:
+ updateCallHeaderRemoteInfoAndLabel(aCallId, aCommandParam);
+ break;
+ case EPhoneViewCreateConference:
+ createConferenceBubble(aCallId, aCommandParam);
+ break;
+ case EPhoneViewGetCallExistsInConference:
+ conferenceCallId(aCallId, aCommandParam);
+ break;
+ default:
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId, aCallId, *aCommandParam );
+}
+
+void PhoneUIQtViewAdapter::ExecuteCommandL (TPhoneViewCommandId aCmdId, TInt aCallId,
+ TDesC &aMessage)
+{
+ switch (aCmdId) {
+ case EPhoneViewUpdateCallHeaderCallDuration:
+ {
+ QString duration ((QChar*)aMessage.Ptr (), aMessage.Length ());
+ qDebug() << "call duration: " << duration;
+ m_bubbleWrapper->bubbleManager ().updateCallTime (m_bubbleWrapper->bubbleId (aCallId), duration);
+ break;
+ }
+ default:
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId, aCallId, &aMessage );
+}
+
+TPhoneViewResponseId PhoneUIQtViewAdapter::HandleCommandL (TPhoneViewCommandId aCmdId)
+{
+ TPhoneViewResponseId response = EPhoneViewResponseSuccess;
+
+ switch (aCmdId) {
+ case EPhoneIsDTMFDialerVisible:
+ case EPhoneViewIsDTMFEditorVisible: //TODO
+ case EPhoneIsCustomizedDialerVisible:
+ case EPhoneViewGetNeedToSendToBackgroundStatus:
+ // TODO: currently not supported
+ response = EPhoneViewResponseFailed;
+ break;
+ case EPhoneViewIsMenuBarVisible:
+ {
+ //TODO
+ response = EPhoneViewResponseFailed;
+ break;
+ }
+ case EPhoneViewGetNumberEntryIsVisibleStatus:
+ case EPhoneViewGetNumberEntryIsUsedStatus: // Fall through
+ {
+ response = (m_view.isDialpadVisible() && !m_dialpadAboutToClose) ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ break;
+ }
+ default:
+ break;
+ }
+
+ return response;
+}
+
+TPhoneViewResponseId PhoneUIQtViewAdapter::HandleCommandL (TPhoneViewCommandId aCmdId,
+ TPhoneCommandParam *aCommandParam)
+{
+ TPhoneViewResponseId viewResponse = EPhoneViewResponseSuccess;
+
+ switch (aCmdId) {
+ case EPhoneViewGetCallIdByState:
+ viewResponse = callIdByState (aCommandParam);
+ break;
+ case EPhoneViewSelectedConfMember:
+ viewResponse = getSelectedConferenceMember (aCommandParam);
+ break;
+ default:
+ break;
+ }
+
+ return viewResponse;
+}
+
+void PhoneUIQtViewAdapter::ExecuteCommand (TPhoneViewCommandId aCmdId)
+{
+ switch (aCmdId) {
+ case EPhoneSetConferenceExpanded:
+ m_bubbleWrapper->bubbleManager ().startChanges ();
+ m_bubbleWrapper->bubbleManager().setExpandedConferenceCallHeader(
+ m_bubbleWrapper->conferenceCallList().size());
+ m_bubbleWrapper->bubbleManager ().endChanges ();
+ break;
+ default:
+ break;
+ }
+}
+
+void PhoneUIQtViewAdapter::ExecuteCommand (TPhoneViewCommandId aCmdId, TPhoneCommandParam *aCommandParam)
+{
+ switch (aCmdId) {
+ case EPhoneViewGetAudioVolumeLevel:
+ writeAudioVolumeLevel (aCommandParam);
+ break;
+ case EPhoneViewGetNumberFromEntry:
+ getNumberFromDialpad(aCommandParam);
+ break;
+ case EPhoneViewSetDtmfOptionsFlag:
+ //TODO
+ break;
+ case EPhoneViewSetVideoCallDTMFVisibilityFlag:
+ //TODO
+ break;
+ case EPhoneViewBackButtonVisible: {
+ TPhoneCmdParamBoolean *param = static_cast<TPhoneCmdParamBoolean *>(aCommandParam);
+ m_view.setBackButtonVisible(param->Boolean());
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+const TDesC& PhoneUIQtViewAdapter::FetchContent ()
+{
+ return KNullDesC;
+}
+
+void PhoneUIQtViewAdapter::dialpadClosed()
+{
+ m_dialpadAboutToClose = true;
+ setCallMenu();
+}
+
+PhoneNoteController* PhoneUIQtViewAdapter::noteController() const
+{
+ return m_noteController;
+}
+
+void PhoneUIQtViewAdapter::keyReleased(QKeyEvent */*event*/)
+{
+ if (m_view.isDialpadVisible() &&
+ false == m_dialpadAboutToClose ) {
+ setDialpadMenu();
+ }
+}
+
+void PhoneUIQtViewAdapter::setTopApplication (TPhoneCommandParam *commandParam)
+{
+ TPhoneCmdParamInteger *integerParam = static_cast<TPhoneCmdParamInteger *> (commandParam);
+ CPhonePubSubProxy::Instance()->ChangePropertyValue(
+ KPSUidUikon,
+ KUikVideoCallTopApp,
+ integerParam->Integer() );
+
+ // Hide the Phone icon if it is not the top application
+ // TODO: how to do this?
+}
+
+int PhoneUIQtViewAdapter::idleAppUid ()
+{
+// <-- QT HS START -->
+ /* if ( m_idleUid == -1 ) {
+ // Get Idle's UID from PubSub.
+ m_idleUid = CPhonePubSubProxy::Instance()->Value (KPSUidAiInformation,
+ KActiveIdleUid );
+ }*/
+ m_idleUid=0x20022F35;
+// <-- QT HS END -->
+ return m_idleUid;
+}
+
+void PhoneUIQtViewAdapter::createCallHeader(
+ int callId,
+ TPhoneCommandParam *commandParam )
+{
+ qDebug () << "PhoneUIQtViewAdapter::createCallHeader";
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdCallHeaderData);
+
+ TPhoneCmdParamCallHeaderData &data =
+ static_cast<TPhoneCmdParamCallHeaderData &> (*commandParam);
+
+ m_bubbleWrapper->bubbleManager ().startChanges ();
+
+ if (m_bubbleWrapper->bubbleManager().isConferenceExpanded())
+ {
+ m_bubbleWrapper->bubbleManager().setExpandedConferenceCallHeader(false);
+ }
+
+ int bubble = m_bubbleWrapper->createCallHeader (callId);
+ m_bubbleWrapper->setState (callId, bubble, data.CallState ());
+ m_bubbleWrapper->setCli (bubble, data.CLIText ());
+ m_bubbleWrapper->setServiceId(callId, data.ServiceId());
+ m_bubbleWrapper->setSecondaryCli (bubble, data.CNAPText ());
+ m_bubbleWrapper->setLabel (bubble, data.LabelText ());
+ m_bubbleWrapper->setCallType (bubble, data.CallType ());
+ m_bubbleWrapper->setDivert (bubble, data.Diverted ());
+ if (data.Picture().Length()) {
+ QString imagePath =
+ QString::fromUtf16(data.Picture().Ptr(),data.Picture().Length());
+ m_bubbleWrapper->bubbleManager().setCallObjectImage(bubble,imagePath);
+ } else {
+ m_bubbleWrapper->bubbleManager().setCallObjectFromTheme(bubble);
+ }
+ m_bubbleWrapper->bubbleManager ().endChanges ();
+}
+
+void PhoneUIQtViewAdapter::createEmergencyCallHeader(
+ int callId,
+ TPhoneCommandParam *commandParam)
+{
+ qDebug () << "PhoneUIQtViewAdapter::createEmergencyCallHeader";
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdEmergencyCallHeaderData);
+
+ TPhoneCmdParamEmergencyCallHeaderData &data =
+ static_cast<TPhoneCmdParamEmergencyCallHeaderData &> (*commandParam);
+
+ m_bubbleWrapper->bubbleManager ().startChanges ();
+ int bubble = m_bubbleWrapper->createCallHeader (callId);
+ m_bubbleWrapper->setLabel (bubble, data.LabelText ());
+ m_bubbleWrapper->setCli (bubble, data.HeaderText ());
+ m_bubbleWrapper->bubbleManager ().endChanges ();
+}
+
+void PhoneUIQtViewAdapter::updateCallHeaderState (
+ int callId,
+ TPhoneCommandParam *commandParam)
+{
+ qDebug () << "PhoneUIQtViewAdapter::updateCallHeaderState";
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdCallHeaderData);
+
+ TPhoneCmdParamCallHeaderData &data =
+ static_cast<TPhoneCmdParamCallHeaderData &> (*commandParam);
+
+
+
+ int bubble = m_bubbleWrapper->bubbleId (callId);
+ if ( -1 != bubble ) {
+ m_bubbleWrapper->bubbleManager ().startChanges ();
+ m_bubbleWrapper->setState (callId, bubble, data.CallState ());
+ m_bubbleWrapper->setLabel (bubble, data.LabelText ());
+ m_bubbleWrapper->setDivert (bubble, data.Diverted ());
+ m_bubbleWrapper->bubbleManager ().endChanges ();
+ }
+
+}
+
+void PhoneUIQtViewAdapter::updateCallHeaderRemoteInfo (int callId, TPhoneCommandParam *commandParam)
+{
+ qDebug () << "PhoneUIQtViewAdapter::updateCallHeaderRemoteInfo";
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdCallHeaderData);
+
+ TPhoneCmdParamCallHeaderData &data =
+ static_cast<TPhoneCmdParamCallHeaderData &> (*commandParam);
+
+
+ int bubble = m_bubbleWrapper->bubbleId (callId);
+ if ( -1 != bubble ) {
+ m_bubbleWrapper->bubbleManager ().startChanges ();
+ m_bubbleWrapper->setCli (bubble, data.CLIText ());
+ m_bubbleWrapper->setSecondaryCli (bubble, data.CNAPText ());
+ m_bubbleWrapper->setDivert (bubble, data.Diverted ());
+ m_bubbleWrapper->bubbleManager ().endChanges ();
+ }
+
+}
+
+void PhoneUIQtViewAdapter::updateCallHeaderRemoteInfoAndLabel (int callId, TPhoneCommandParam *commandParam)
+{
+ qDebug () << "PhoneUIQtViewAdapter::updateCallHeaderRemoteInfoAndLabel";
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdCallHeaderData);
+
+ TPhoneCmdParamCallHeaderData &data =
+ static_cast<TPhoneCmdParamCallHeaderData &> (*commandParam);
+
+ int bubble = m_bubbleWrapper->bubbleId (callId);
+ if ( -1 != bubble ) {
+ m_bubbleWrapper->bubbleManager ().startChanges ();
+ m_bubbleWrapper->setCli (bubble, data.CLIText ());
+ m_bubbleWrapper->setSecondaryCli (bubble, data.CNAPText ());
+ m_bubbleWrapper->setLabel (bubble, data.LabelText ());
+ m_bubbleWrapper->setDivert (bubble, data.Diverted ());
+ m_bubbleWrapper->bubbleManager ().endChanges ();
+ }
+}
+
+TPhoneViewResponseId PhoneUIQtViewAdapter::callIdByState (TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdCallStateData);
+
+ TPhoneCmdParamCallStateData &stateParam =
+ static_cast<TPhoneCmdParamCallStateData &>(*commandParam);
+
+ stateParam.SetCallId (m_bubbleWrapper->callId (stateParam.CallState ()));
+ return EPhoneViewResponseSuccess;
+}
+
+void PhoneUIQtViewAdapter::setTouchButtons (TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdBoolean);
+
+ TPhoneCmdParamBoolean ¶m =
+ static_cast<TPhoneCmdParamBoolean &>(*commandParam);
+ bool emergencyCall = param.Boolean();
+
+ m_bubbleWrapper->bubbleManager ().startChanges ();
+ m_view.clearParticipantListActions();
+
+ QList<int> bubbles = m_bubbleWrapper->bubbles().keys();
+
+ for (int j = 0; j < bubbles.size(); ++j){
+ int callId = bubbles.at(j);
+ // Clear bubble
+ m_view.clearBubbleCommands(m_bubbleWrapper->bubbles().value(callId));
+
+ // Get bubble actions by call type
+ QMap<PhoneAction::ActionType, PhoneAction *> actions =
+ m_uiCommandController->pushButtonActionsForCall(
+ m_bubbleWrapper->callStates().value(callId),
+ emergencyCall,
+ m_bubbleWrapper->callStates(),
+ m_bubbleWrapper->serviceIds(),
+ m_bubbleWrapper->serviceIdByCallId(callId),
+ callId);
+
+ QList<PhoneAction *> values = actions.values();
+ for (int i = 0; i < values.size (); ++i) {
+ PhoneAction *action = values.at (i);
+ m_view.addBubbleCommand(m_bubbleWrapper->bubbles().value(callId),
+ *action);
+ delete action;
+ }
+ }
+
+ setParticipantListActions();
+ setExpandedConferenceCallHeader();
+ setMenu();
+
+ m_bubbleWrapper->bubbleManager ().endChanges ();
+}
+
+void PhoneUIQtViewAdapter::setToolbarButtons (TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdInteger);
+
+ TPhoneCmdParamInteger &intParam =
+ static_cast<TPhoneCmdParamInteger &>(*commandParam);
+
+ QMap<PhoneAction::ActionType, PhoneAction *> actions = m_resourceAdapter->convert (intParam.Integer ());
+ QList<PhoneAction*> values = actions.values();
+
+ if (actions.count()) {
+ m_view.setToolbarActions(values);
+ }
+
+ qDeleteAll(actions);
+}
+
+void PhoneUIQtViewAdapter::setCallHoldFlag (TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdBoolean);
+
+ TPhoneCmdParamBoolean &boolParam =
+ static_cast<TPhoneCmdParamBoolean &>(*commandParam);
+
+ m_resourceAdapter->buttonsController()->setButtonFlags(PhoneUIQtButtonsController::Hold,
+ boolParam.Boolean ());
+}
+
+void PhoneUIQtViewAdapter::callHoldFlag (TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdBoolean);
+
+ TPhoneCmdParamBoolean &boolParam =
+ static_cast<TPhoneCmdParamBoolean &>(*commandParam);
+ boolParam.SetBoolean (m_resourceAdapter->buttonsController()->getButtonFlags(PhoneUIQtButtonsController::Hold));
+}
+
+void PhoneUIQtViewAdapter::writeAudioVolumeLevel (TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdInteger);
+
+ TPhoneCmdParamInteger &intParam =
+ static_cast<TPhoneCmdParamInteger &>(*commandParam);
+ intParam.SetInteger (m_view.volumeSliderValue ());
+}
+
+void PhoneUIQtViewAdapter::setAudioVolumeSliderValue (TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdInteger);
+
+ TPhoneCmdParamInteger &intParam =
+ static_cast<TPhoneCmdParamInteger &>(*commandParam);
+
+ m_view.setVolumeSliderValue(intParam.Integer(),
+ EPhoneInCallCmdSetVolumeLevel,
+ KPhoneVolumeMaxValue,
+ KPhoneVolumeMinValue );
+}
+
+void PhoneUIQtViewAdapter::setMuteIndication (TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdBoolean);
+ TPhoneCmdParamBoolean &boolParam =
+ static_cast<TPhoneCmdParamBoolean &>(*commandParam);
+ m_bubbleWrapper->bubbleManager().setPhoneMuted(boolParam.Boolean());
+}
+
+void PhoneUIQtViewAdapter::activeCallCount (TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdInteger);
+
+ TPhoneCmdParamInteger &integerParam =
+ static_cast<TPhoneCmdParamInteger&>(*commandParam);
+ integerParam.SetInteger (m_bubbleWrapper->activeCallCount());
+}
+
+void PhoneUIQtViewAdapter::setAudioPath (TPhoneCommandParam *commandParam)
+ {
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdAudioOutput);
+
+ TPhoneCmdParamAudioOutput &outputParam =
+ static_cast<TPhoneCmdParamAudioOutput &>(*commandParam);
+
+ m_resourceAdapter->buttonsController()->setButtonFlags(PhoneUIQtButtonsController::Ihf,
+ outputParam.AudioOutput() == EPELoudspeaker);
+ m_resourceAdapter->buttonsController()->setButtonFlags(PhoneUIQtButtonsController::Wired,
+ outputParam.AudioOutput() == EPEWiredAudioAccessory);
+ m_resourceAdapter->buttonsController()->setButtonFlags(PhoneUIQtButtonsController::Btaa,
+ outputParam.AudioOutput() == EPEBTAudioAccessory);
+ }
+
+void PhoneUIQtViewAdapter::expandedBubbleCallId(TPhoneCommandParam *commandParam)
+ {
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdInteger);
+
+ TPhoneCmdParamInteger &outputParam =
+ static_cast<TPhoneCmdParamInteger &>(*commandParam);
+ int callId = PHONE_CALL_NOT_FOUND;
+
+ if ( 0<m_bubbleWrapper->callStates().keys().size() ) {
+ int bubbleId = m_bubbleWrapper->bubbleManager().expandedBubble();
+ callId = m_bubbleWrapper->callIdByBubbleId(bubbleId);
+ }
+
+ outputParam.SetInteger( callId );
+ }
+
+void PhoneUIQtViewAdapter::openDialpad()
+ {
+ m_dialpadAboutToClose = false;
+ m_view.showDialpad();
+ setDialpadMenu();
+ }
+
+void PhoneUIQtViewAdapter::createConferenceBubble(int callId, TPhoneCommandParam *commandParam)
+{
+ qDebug () << "PhoneUIQtViewAdapter::createConferenceBubble";
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdCallHeaderData);
+
+ TPhoneCmdParamCallHeaderData &data =
+ static_cast<TPhoneCmdParamCallHeaderData &> (*commandParam);
+
+ m_bubbleWrapper->createConferenceBubble(
+ callId, data.CallState(), data.LabelText(), data.CLIText());
+
+ m_bubbleWrapper->setServiceId(callId,data.ServiceId());
+}
+
+void PhoneUIQtViewAdapter::conferenceCallId(int callId, TPhoneCommandParam *commandParam)
+{
+ qDebug () << "PhoneUIQtViewAdapter::conferenceCallId";
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdBoolean);
+
+ TPhoneCmdParamBoolean* conferenceDataValue =
+ static_cast<TPhoneCmdParamBoolean*>(
+ commandParam );
+
+ conferenceDataValue->SetBoolean(m_bubbleWrapper->conferenceCallId(callId));
+}
+
+void PhoneUIQtViewAdapter::removeConferenceBubble()
+{
+ m_bubbleWrapper->bubbleManager().startChanges();
+ m_view.removeExpandAction(m_bubbleWrapper->bubbleId(KConferenceCallId));
+ m_bubbleWrapper->removeConferenceBubble();
+ m_bubbleWrapper->bubbleManager().endChanges();
+}
+
+void PhoneUIQtViewAdapter::isConference(TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdBoolean);
+
+ TPhoneCmdParamBoolean* conferenceDataValue =
+ static_cast<TPhoneCmdParamBoolean*>(
+ commandParam );
+
+ conferenceDataValue->SetBoolean(0<m_bubbleWrapper->conferenceCallList().size());
+}
+
+void PhoneUIQtViewAdapter::removeCallFromConference(int callId)
+{
+ m_bubbleWrapper->bubbleManager().startChanges();
+ m_bubbleWrapper->removeCallFromConference(callId);
+ int bubbleId = m_bubbleWrapper->bubbles().value(callId);
+ m_view.clearBubbleCommands(bubbleId);
+ m_view.removeExpandAction(bubbleId);
+ m_bubbleWrapper->removeCallHeader(callId);
+ m_bubbleWrapper->bubbleManager().endChanges();
+}
+
+TPhoneViewResponseId PhoneUIQtViewAdapter::getSelectedConferenceMember(
+ TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdInteger);
+ TPhoneViewResponseId ret = EPhoneViewResponseSuccess;
+ TPhoneCmdParamInteger* integerValue =
+ static_cast<TPhoneCmdParamInteger*>(
+ commandParam );
+
+ int bubbleId = m_bubbleWrapper->bubbleManager().selectionIdInConference();
+ int callId = m_bubbleWrapper->callIdByBubbleId(bubbleId);
+
+ if (callId == -1) {
+ ret = EPhoneViewResponseFailed;
+ } else {
+ integerValue->SetInteger(callId);
+ }
+
+ return ret;
+}
+
+void PhoneUIQtViewAdapter::setPrivateFromConference(int callId)
+{
+ m_bubbleWrapper->bubbleManager().startChanges();
+ m_bubbleWrapper->bubbleManager().setExpandedConferenceCallHeader(false);
+ m_bubbleWrapper->removeCallFromConference(callId);
+ m_view.clearBubbleCommands(m_bubbleWrapper->bubbles().value(callId));
+ m_bubbleWrapper->bubbleManager().endChanges();
+}
+
+void PhoneUIQtViewAdapter::setExpandActions()
+{
+ /* If there is 2 or more calls ongoing then we should
+ * enable expancion swap*/
+ int heldBubble = -1;
+
+ if ( 2 <= m_bubbleWrapper->callStates().values().size() ) {
+ if (callsExists(EPEStateConnected,EPEStateHeld)) {
+ heldBubble =
+ m_bubbleWrapper->bubbleId(m_bubbleWrapper->callId(EPEStateHeld));
+ m_view.setExpandAction(heldBubble, EPhoneInCallCmdSwap);
+ } else if (callsExists(EPEStateConnected,EPEStateHeldConference)) {
+ heldBubble =
+ m_bubbleWrapper->bubbleId(m_bubbleWrapper->callId(EPEStateHeldConference));
+ m_view.setExpandAction(heldBubble, EPhoneInCallCmdSwap);
+ } else if (callsExists(EPEStateRinging,EPEStateHeld)) {
+ heldBubble =
+ m_bubbleWrapper->bubbleId(m_bubbleWrapper->callId(EPEStateHeld));
+ m_view.setExpandAction(heldBubble, EPhoneInCallCmdUnhold);
+ }
+
+ QList<int> calls = m_bubbleWrapper->bubbles().keys();
+ foreach (int call, calls) {
+ int bubbleId = m_bubbleWrapper->bubbleId(call);
+ if ( bubbleId != heldBubble ) {
+ m_view.setExpandAction(bubbleId, EPhoneCmdUpdateUiControls);
+ }
+ }
+ }
+}
+
+bool PhoneUIQtViewAdapter::callsExists(int call1State, int call2State)
+{
+ bool callsExist(false);
+ if ( m_bubbleWrapper->callStates().values().contains(call1State) &&
+ m_bubbleWrapper->callStates().values().contains(call2State) ) {
+ callsExist = true;
+ }
+ return callsExist;
+}
+
+void PhoneUIQtViewAdapter::setParticipantListActions()
+{
+ if ( 0<m_bubbleWrapper->conferenceCallList().size() ) {
+ m_view.addParticipantListAction(
+ EPhoneInCallCmdPrivate,
+ hbTrId("txt_phone_button_private"),
+ HbIcon(":/qtg_mono_private_call.svg.svg"));
+ m_view.addParticipantListAction(
+ EPhoneInCallCmdDrop,
+ hbTrId("txt_phone_button_drop"),
+ HbIcon(":/qtg_mono_drop_call.svg.svg"));
+ }
+}
+
+void PhoneUIQtViewAdapter::setExpandedConferenceCallHeader()
+{
+ int callId = PHONE_CALL_NOT_FOUND;
+
+ if ( 1==m_bubbleWrapper->bubbles().keys().size()
+ || (1<m_bubbleWrapper->bubbles().keys().size()
+ && false == m_bubbleWrapper->callStates().values().contains(EPEStateRinging)
+ && false == m_bubbleWrapper->callStates().values().contains(EPEStateDialing)
+ && false == m_bubbleWrapper->callStates().values().contains(EPEStateConnecting)
+ && false == m_bubbleWrapper->callStates().values().contains(EPEStateHeldConference))) {
+
+ int bubbleId = m_bubbleWrapper->bubbleManager().expandedBubble();
+ callId = m_bubbleWrapper->callIdByBubbleId(bubbleId);
+ }
+
+ m_bubbleWrapper->bubbleManager().setExpandedConferenceCallHeader(
+ (KConferenceCallId == callId));
+}
+
+void PhoneUIQtViewAdapter::bringToForeground()
+{
+ m_view.bringToForeground();
+}
+
+void PhoneUIQtViewAdapter::showGlobalNote(
+ TPhoneCommandParam *commandParam)
+{
+ m_noteController->showGlobalNote(commandParam);
+}
+
+void PhoneUIQtViewAdapter::setDialpadVisibility(
+ TPhoneCommandParam *commandParam)
+{
+ Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdBoolean);
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>(commandParam);
+
+ if (booleanParam->Boolean()) {
+ m_dialpadAboutToClose = false;
+ m_view.showDialpad();
+ } else {
+ m_view.hideDialpad();
+ }
+}
+
+void PhoneUIQtViewAdapter::removeAllCallHeaders()
+{
+ if (m_bubbleWrapper->conferenceCallList().size()) {
+ removeConferenceBubble();
+ }
+
+ QList<int> callIds = m_bubbleWrapper->bubbles().keys();
+
+ for (int i=0; i<callIds.size(); ++i) {
+ int callId = callIds.at(i);
+ if (KEmergencyCallId != callId) {
+ m_bubbleWrapper->bubbleManager().startChanges();
+ int bubble = m_bubbleWrapper->bubbles().value(callId);
+ m_view.clearBubbleCommands(bubble);
+ m_view.removeExpandAction(bubble);
+ m_bubbleWrapper->removeCallHeader (callId);
+ m_bubbleWrapper->bubbleManager().endChanges();
+ }
+ }
+}
+
+void PhoneUIQtViewAdapter::getNumberFromDialpad(
+ TPhoneCommandParam *commandParam)
+{
+
+ TPhoneCmdParamString* entryContent =
+ static_cast<TPhoneCmdParamString*>(commandParam);
+
+ (*entryContent->String()).Copy(m_view.dialpadText().utf16());
+}
+
+void PhoneUIQtViewAdapter::getDialpadStringLength(
+ TPhoneCommandParam *commandParam)
+{
+
+ TPhoneCmdParamInteger* integerParam =
+ static_cast<TPhoneCmdParamInteger*>(commandParam);
+
+ integerParam->SetInteger(m_view.dialpadText().length());
+}
+
+void PhoneUIQtViewAdapter::removeDialpad()
+{
+ m_view.clearAndHideDialpad();
+}
+
+void PhoneUIQtViewAdapter::addToConference()
+{
+ m_bubbleWrapper->addToConferenceBubble();
+}
+
+void PhoneUIQtViewAdapter::setMenu()
+{
+ if (m_view.isDialpadVisible() && false == m_dialpadAboutToClose) {
+ setDialpadMenu();
+ } else {
+ setCallMenu();
+ }
+}
+
+void PhoneUIQtViewAdapter::setCallMenu()
+{
+ int bubbleId = m_bubbleWrapper->bubbleManager().expandedBubble();
+ int callId = m_bubbleWrapper->callIdByBubbleId(bubbleId);
+ m_uiCommandController->setCallMenuActions(
+ m_bubbleWrapper->callStates(),
+ m_bubbleWrapper->serviceIds(),
+ m_bubbleWrapper->serviceIdByCallId(callId),
+ callId );
+
+}
+
+void PhoneUIQtViewAdapter::setDialpadMenu()
+{
+ m_uiCommandController->setDialpadMenuActions();
+}
+
+void PhoneUIQtViewAdapter::showNote(TPhoneCommandParam *commandParam)
+{
+ m_noteController->showNote(commandParam);
+}
+