diff -r c84cf270c54f -r 92ab7f8d0eab phoneapp/phoneuiqtviewadapter/src/phoneuiqtviewadapter.cpp
--- /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 &param =
+        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);
+}
+