diff -r 40a3f856b14d -r 41a7f70b3818 phoneapp/phoneuiqtviewadapter/src/phoneuiqtviewadapter.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/phoneapp/phoneuiqtviewadapter/src/phoneuiqtviewadapter.cpp	Tue Aug 31 15:14:29 2010 +0300
@@ -0,0 +1,1317 @@
+/*!
+* 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 "tphonecmdparamkeycapture.h"
+#include "cphonepubsubproxy.h"
+#include "pevirtualengine.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 "phonemessagecontroller.h"
+#include "phoneindicatorcontroller.h"
+#include "qtphonelog.h"
+#include "phonevisibilityhandler.h"
+#include "phoneapplauncher.h"
+#include "cphonecenrepproxy.h"
+
+#include <UikonInternalPSKeys.h>
+#include <bubblemanagerif.h>
+#include <hbaction.h>
+#include <pevirtualengine.h>
+#include <QtGlobal>
+#include <xqserviceutil.h>
+#include <hbinstance.h>
+#include <QKeyEvent>
+#include <hbextendedlocale.h>
+#include <hbi18ndef.h>
+#include <eikenv.h>
+#include <w32std.h>
+#include <hbstringutil.h>
+#include <AknSgcc.h>
+#include <AknCapServerClient.h>
+#include <xqaiwdecl.h>
+
+
+//CONSTANTS
+static const int PHONE_CALL_NOT_FOUND = -1;
+
+const TUid KCRUidTelTouchButtons = {0x2001B2E6};
+const TUint32 KTelIncallTouchButtons   = 0x00000001;
+
+
+inline Qt::TextElideMode clipToElide(
+    TPhoneCmdParamCallHeaderData::TPhoneTextClippingDirection clip)
+    {
+    return clip == TPhoneCmdParamCallHeaderData::ELeft ? 
+                   Qt::ElideLeft : Qt::ElideRight;
+    }
+
+PhoneUIQtViewAdapter::PhoneUIQtViewAdapter (PhoneUIQtViewIF &view, QObject *parent) :
+    QObject (parent),
+    m_view (view),
+    m_idleUid(-1),
+    m_bubbleWrapper(0),
+    m_ringingtonecontroller(0),
+    m_resourceAdapter(0),
+    m_noteController(0),
+    m_telephonyService(0),
+    m_uiCommandController(0),
+    m_messageController(0),
+    m_indicatorController(0),
+    m_dialpadAboutToClose(false),
+    m_homeScreenToForeground(false),
+    m_visibilityHandler(0),
+    m_appLauncher(0),
+    m_clearDialpadOnClose(true),
+    m_speakerAsDefaultButton(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);
+    m_visibilityHandler = new PhoneVisibilityHandler(view, this);
+    m_indicatorController = new PhoneIndicatorController(*m_visibilityHandler,this);
+    m_appLauncher = new PhoneAppLauncher(this);
+    m_messageController = new PhoneMessageController(*m_appLauncher, this);
+    
+    int touchButton(-1);
+    if ( KErrNone == CPhoneCenRepProxy::Instance()->GetInt(
+            KCRUidTelTouchButtons,
+            KTelIncallTouchButtons,
+            touchButton ) ) {
+        if ( touchButton == 2 ) {
+            m_speakerAsDefaultButton = true;
+        }    
+    }
+
+}
+
+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 EPhoneViewHideNaviPaneAudioVolume:
+        m_view.removeVolumeSlider ();
+        break;
+
+    case EPhoneViewOpenDialer:
+        openDialpad();
+        break;
+
+    case EPhoneViewRemoveConferenceBubble:
+        removeConferenceBubble();
+        break;
+
+    case EPhoneViewSendToBackground:
+    case EPhoneViewBringIdleToForeground:
+        m_visibilityHandler->sendToBackground(m_homeScreenToForeground);
+        m_homeScreenToForeground = false;
+        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;
+    case EPhoneViewUpdateFSW:
+        setHidden(true);
+        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();
+        
+        if (!m_bubbleWrapper->bubbles().count()) {
+            m_indicatorController->clearActiveCallData();
+        }
+        }
+        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;
+    case EPhoneViewOpenSoftRejectEditor:
+        m_visibilityHandler->hideDeviceDialogs(false);
+        m_messageController->openSoftRejectMessageEditor(aCommandParam);
+        break;
+    case EPhoneViewSetGlobalNotifiersDisabled:
+        hideDeviceDialogs(aCommandParam);
+        break;
+    case EPhoneViewLaunchLogs: 
+        openLogs(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;
+    case EPhoneViewUpdateCallHeaderCallDuration:
+    {
+        TPhoneCmdParamInteger *time = static_cast<TPhoneCmdParamInteger *>(aCommandParam);
+        QString duration = convertDuration(time->Integer());
+        PHONE_DEBUG2("call duration:", duration);
+        int bubbleId = m_bubbleWrapper->bubbleId(aCallId);
+        
+        if (-1 != bubbleId) {
+            m_bubbleWrapper->bubbleManager().updateCallTime(bubbleId, duration);
+        }
+        break;
+    }
+
+    case EPhoneViewCipheringInfoChange:
+    {
+        handleCipheringInfoChange(aCallId, aCommandParam);
+        break;
+    }
+
+    default:
+        break;
+    }
+    CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId, aCallId, *aCommandParam );
+}
+
+void PhoneUIQtViewAdapter::ExecuteCommandL (TPhoneViewCommandId aCmdId, TInt aCallId,
+    TDesC &aMessage)
+{
+    switch (aCmdId) {
+
+    default:
+        break;
+    }
+    CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId, aCallId, &aMessage );
+}
+
+TPhoneViewResponseId PhoneUIQtViewAdapter::HandleCommandL (TPhoneViewCommandId aCmdId)
+{
+    TPhoneViewResponseId response = EPhoneViewResponseSuccess;
+
+    switch (aCmdId) {
+    case EPhoneIsDTMFDialerVisible:
+    case EPhoneIsCustomizedDialerVisible:
+    case EPhoneViewGetNeedToSendToBackgroundStatus:
+        // TODO: currently not supported
+        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;
+    case EPhoneViewBeginUpdate:
+        m_bubbleWrapper->bubbleManager ().startChanges ();
+        break;
+    case EPhoneViewEndUpdate:
+        m_bubbleWrapper->bubbleManager ().endChanges ();
+        break;
+    case EPhoneViewOpenContacts:
+        openContacts();
+        break;
+    default:
+        break;
+    }
+}
+
+void PhoneUIQtViewAdapter::ExecuteCommand (TPhoneViewCommandId aCmdId, TPhoneCommandParam *aCommandParam)
+{
+    switch (aCmdId) {
+    case EPhoneViewGetAudioVolumeLevel:
+        writeAudioVolumeLevel (aCommandParam);
+        break;
+    case EPhoneViewGetNumberFromEntry:
+        getNumberFromDialpad(aCommandParam);
+        break;
+    case EPhoneViewBackButtonActive: {
+        TPhoneCmdParamBoolean *param = static_cast<TPhoneCmdParamBoolean *>(aCommandParam);
+        m_view.setBackButtonVisible(param->Boolean());
+		}
+        break;
+    case EPhoneViewHsToForegroundAfterCall: {
+        TPhoneCmdParamBoolean *param = static_cast<TPhoneCmdParamBoolean *>(aCommandParam);
+        m_homeScreenToForeground = param->Boolean();
+        }
+        break;
+    case EPhoneViewSetIhfFlag: {
+        TPhoneCmdParamBoolean *param = static_cast<TPhoneCmdParamBoolean *>(aCommandParam);
+
+        PhoneResourceAdapter::Instance()->buttonsController()->
+                setButtonFlags(PhoneUIQtButtonsController::Ihf, 
+                               param->Boolean());
+        }
+        break;
+    case EPhoneViewSetMuteFlag: {
+        TPhoneCmdParamBoolean *param = static_cast<TPhoneCmdParamBoolean *>(aCommandParam);
+
+        PhoneResourceAdapter::Instance()->buttonsController()->
+                setButtonFlags(PhoneUIQtButtonsController::Mute, 
+                               param->Boolean());
+        }
+        break;
+    case EPhoneViewSetBlueToothFlag: {
+        TPhoneCmdParamBoolean *param = static_cast<TPhoneCmdParamBoolean *>(aCommandParam);
+
+        PhoneResourceAdapter::Instance()->buttonsController()->
+                setButtonFlags(PhoneUIQtButtonsController::Btaa, 
+                               param->Boolean());
+        }
+        break;
+    case EPhoneViewSetBluetoothAvailableFlag: {
+        TPhoneCmdParamBoolean *param = static_cast<TPhoneCmdParamBoolean *>(aCommandParam);
+    
+        PhoneResourceAdapter::Instance()->buttonsController()->
+                setButtonFlags(PhoneUIQtButtonsController::BluetoothAvailable, 
+                               param->Boolean());
+        }
+        break;
+    case EPhoneViewStartCapturingKey: {
+        TPhoneCmdParamKeyCapture *captureParam = 
+                static_cast<TPhoneCmdParamKeyCapture *>(aCommandParam);        
+        Qt::Key qtKey;
+        
+        if (convertKey(captureParam->KeyCode(), qtKey)) {
+            m_view.captureKey(qtKey, true);
+        }
+    }
+    break;
+    case EPhoneViewStopCapturingKey: {
+        TPhoneCmdParamKeyCapture *captureParam = 
+                static_cast<TPhoneCmdParamKeyCapture *>(aCommandParam);        
+        Qt::Key qtKey;
+        
+        if (convertKey(captureParam->KeyCode(), qtKey)) {
+            m_view.captureKey(qtKey, false);
+        }
+    }
+    break;
+    default:
+        break;
+    }
+}
+
+const TDesC& PhoneUIQtViewAdapter::FetchContent ()
+{
+    return KNullDesC;
+}
+
+void PhoneUIQtViewAdapter::dialpadClosed()
+{
+    if (m_clearDialpadOnClose) {
+        m_view.clearDialpad();
+    }
+    m_dialpadAboutToClose = true;
+    m_clearDialpadOnClose = true;
+    setCallMenu();
+}
+
+PhoneNoteController* PhoneUIQtViewAdapter::noteController() const
+{
+    return m_noteController;
+}
+
+void PhoneUIQtViewAdapter::keyReleased(QKeyEvent */*event*/)
+{
+    if (m_view.isDialpadVisible() &&
+        false == m_dialpadAboutToClose ) {
+        setDialpadMenu();
+    }
+}
+
+void PhoneUIQtViewAdapter::handleWindowActivated()
+{
+    m_indicatorController->disableActiveCallIndicator();
+}
+
+void PhoneUIQtViewAdapter::handleWindowDeactivated()
+{
+    m_indicatorController->enableActiveCallIndicator();
+}
+
+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 )
+{
+    PHONE_DEBUG("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 (), clipToElide(data.CLITextClippingDirection()));
+    m_bubbleWrapper->setServiceId(callId, data.ServiceId());
+    m_bubbleWrapper->setSecondaryCli (bubble, data.CNAPText (), clipToElide(data.CNAPTextClippingDirection()));
+    m_bubbleWrapper->setLabel (bubble, data.LabelText ());
+    m_bubbleWrapper->setCallType (bubble, data.CallType ());
+    m_bubbleWrapper->setDivert (bubble, data.Diverted ());
+    m_bubbleWrapper->setCiphering(bubble, data.CipheringIndicatorAllowed(), data.Ciphering());
+
+    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 ();
+    
+    if (1 == m_bubbleWrapper->bubbles().keys().count()) {
+        setHidden(false);
+    }
+    m_indicatorController->setActiveCallData();
+}
+
+void PhoneUIQtViewAdapter::createEmergencyCallHeader(
+    int callId,
+    TPhoneCommandParam *commandParam)
+{
+    PHONE_DEBUG("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 (), Qt::ElideRight);
+    m_bubbleWrapper->setCiphering(bubble, data.CipheringIndicatorAllowed(), data.Ciphering());
+    m_bubbleWrapper->bubbleManager ().endChanges ();
+    
+    m_indicatorController->setActiveCallData();
+}
+
+void PhoneUIQtViewAdapter::updateCallHeaderState (
+    int callId,
+    TPhoneCommandParam *commandParam)
+{
+    PHONE_DEBUG("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)
+{
+    PHONE_DEBUG("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 (),
+             clipToElide(data.CLITextClippingDirection()));
+         m_bubbleWrapper->setSecondaryCli (bubble, data.CNAPText (),
+             clipToElide(data.CNAPTextClippingDirection()));
+         m_bubbleWrapper->setDivert (bubble, data.Diverted ());
+         m_bubbleWrapper->bubbleManager ().endChanges ();
+     }
+     m_indicatorController->setActiveCallData();
+
+}
+
+void PhoneUIQtViewAdapter::updateCallHeaderRemoteInfoAndLabel (int callId, TPhoneCommandParam *commandParam)
+{
+    PHONE_DEBUG("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 (),
+             clipToElide(data.CLITextClippingDirection()));
+         m_bubbleWrapper->setSecondaryCli (bubble, data.CNAPText (),
+             clipToElide(data.CNAPTextClippingDirection()));
+         m_bubbleWrapper->setLabel (bubble, data.LabelText ());
+         m_bubbleWrapper->setDivert (bubble, data.Diverted ());
+         m_bubbleWrapper->bubbleManager ().endChanges ();
+     }
+}
+
+void PhoneUIQtViewAdapter::handleCipheringInfoChange(int callId, TPhoneCommandParam *commandParam)
+{
+    TPhoneCmdParamCallHeaderData *param =
+        static_cast<TPhoneCmdParamCallHeaderData*>(commandParam);
+
+    int bubble = m_bubbleWrapper->bubbleId(callId);        
+    if ( -1 != bubble ) {        
+        m_bubbleWrapper->bubbleManager().startChanges();
+        m_bubbleWrapper->setCiphering(m_bubbleWrapper->bubbleId(callId),
+                                      param->CipheringIndicatorAllowed(),
+                                      param->Ciphering());
+        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 ();
+
+    QList<int> bubbles = m_bubbleWrapper->bubbles().keys();
+
+    m_resourceAdapter->buttonsController()->setButtonFlags(
+            PhoneUIQtButtonsController::DisableJoin,
+            (5 <= m_bubbleWrapper->conferenceCallList().count()));
+    
+    setCommonButtonFlags();
+
+    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;
+        }
+    }
+
+    setExpandedConferenceCallHeader();
+    setBubbleSelectionFlag();
+    setMenu();
+
+    m_bubbleWrapper->bubbleManager ().endChanges ();
+}
+
+void PhoneUIQtViewAdapter::setToolbarButtons (TPhoneCommandParam *commandParam)
+{
+    Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdInteger);
+
+    TPhoneCmdParamInteger &intParam =
+        static_cast<TPhoneCmdParamInteger &>(*commandParam);
+
+    setCommonButtonFlags();
+    
+    int callId(-1);
+    int serviceId(-1);
+    if ( 0<m_bubbleWrapper->callStates().keys().size() ) {
+        int bubbleId = m_bubbleWrapper->bubbleManager().expandedBubble();
+        callId = m_bubbleWrapper->callIdByBubbleId(bubbleId);
+        serviceId = m_bubbleWrapper->serviceIdByCallId(callId);
+    }
+    
+    QList<PhoneAction*> actions = m_uiCommandController->toolBarActions(
+                                        intParam.Integer(),
+                                        m_bubbleWrapper->callStates(),
+                                        m_bubbleWrapper->serviceIds(),
+                                        serviceId,
+                                        callId );
+    
+    if (actions.count()) {
+        m_view.setToolbarActions(actions);
+    }
+
+    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)
+{
+    PHONE_DEBUG("PhoneUIQtViewAdapter::createConferenceBubble");
+    Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdCallHeaderData);
+
+    TPhoneCmdParamCallHeaderData &data =
+         static_cast<TPhoneCmdParamCallHeaderData &> (*commandParam);
+
+    int bubble = m_bubbleWrapper->createConferenceBubble(
+            callId, data.CallState(), data.LabelText(), data.CLIText());
+
+    m_bubbleWrapper->setServiceId(callId,data.ServiceId());
+    m_bubbleWrapper->setCiphering(bubble, data.CipheringIndicatorAllowed(), data.Ciphering());
+    
+    setParticipantListActions();
+}
+
+void PhoneUIQtViewAdapter::conferenceCallId(int callId, TPhoneCommandParam *commandParam)
+{
+    PHONE_DEBUG("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_view.clearParticipantListActions();
+    m_bubbleWrapper->removeConferenceBubble();
+    m_bubbleWrapper->bubbleManager().endChanges();
+    if (!m_bubbleWrapper->bubbles().count()) {
+        m_indicatorController->clearActiveCallData();
+    }
+
+}
+
+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"));
+        m_view.addParticipantListAction(
+                EPhoneInCallCmdDrop,
+                hbTrId("txt_phone_button_drop"),
+                HbIcon("qtg_mono_drop_call"));
+    }
+}
+
+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_visibilityHandler->bringToForeground();
+}
+
+void PhoneUIQtViewAdapter::hideDeviceDialogs(TPhoneCommandParam *commandParam)
+{
+    Q_ASSERT (commandParam->ParamId () == TPhoneCommandParam::EPhoneParamIdBoolean);
+    TPhoneCmdParamBoolean* booleanParam =
+        static_cast<TPhoneCmdParamBoolean*>(commandParam);
+    m_visibilityHandler->hideDeviceDialogs(booleanParam->Boolean());
+}
+
+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_clearDialpadOnClose = false;
+        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();
+        }
+    }
+    if (!m_bubbleWrapper->bubbles().count()) {
+        m_indicatorController->clearActiveCallData();
+    }
+
+}
+
+void PhoneUIQtViewAdapter::getNumberFromDialpad(
+        TPhoneCommandParam *commandParam)
+{
+
+    TPhoneCmdParamString* entryContent =
+        static_cast<TPhoneCmdParamString*>(commandParam);
+    
+    QString westernNumber = 
+        HbStringUtil::convertDigitsTo(m_view.dialpadText(), WesternDigit);
+    
+    (*entryContent->String()).Copy(westernNumber.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()
+{
+    if ( 0<m_bubbleWrapper->callStates().keys().size() ) {
+        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);
+}
+
+QString PhoneUIQtViewAdapter::convertDuration(TInt secs)
+    {
+    QTime init(0,0,0);
+    QTime duration = init.addSecs(secs);
+    HbExtendedLocale locale = HbExtendedLocale::system();
+    QString durationString = locale.format(duration, QString(r_qtn_time_durat_long));
+    return HbStringUtil::convertDigits(durationString); 
+} 
+
+void PhoneUIQtViewAdapter::setBubbleSelectionFlag()
+{
+    bool selectionFlag = ((m_bubbleWrapper->callStates().
+                              values().contains(EPEStateRinging) &&
+                           m_bubbleWrapper->conferenceCallList().count())||
+                          m_bubbleWrapper->callStates().
+                              values().contains(EPEStateDialing) ||
+                          m_bubbleWrapper->callStates().
+                              values().contains(EPEStateConnecting));
+
+    m_bubbleWrapper->bubbleManager().setBubbleSelectionDisabled(selectionFlag);
+}
+
+void PhoneUIQtViewAdapter::setHidden(bool hidden)
+{
+    TRAP_IGNORE(SetHiddenL(hidden));
+}
+
+void PhoneUIQtViewAdapter::SetHiddenL(bool hidden)
+{
+    CEikonEnv* env = CEikonEnv::Static();
+    
+    if (env) {
+        CApaWindowGroupName* windowGroupName =
+            CApaWindowGroupName::NewLC(
+                    env->WsSession(),
+                    env->RootWin().Identifier() );
+        
+        windowGroupName->SetHidden( hidden );
+        User::LeaveIfError(
+                windowGroupName->SetWindowGroupName(
+                        env->RootWin() ) );
+        
+        CleanupStack::PopAndDestroy( windowGroupName );
+
+        CAknSgcClient::AknSrv()->UpdateTaskList();
+    }
+}
+void PhoneUIQtViewAdapter::openContacts()
+{
+    m_appLauncher->launchContacts();
+}
+
+void PhoneUIQtViewAdapter::openLogs(TPhoneCommandParam *commandParam)
+{
+    TPhoneCmdParamString* entryContent =
+            static_cast<TPhoneCmdParamString*>(commandParam);
+    
+    bool phoneVisible = m_visibilityHandler->phoneVisible();
+    
+    m_homeScreenToForeground = false;
+    m_visibilityHandler->sendToBackground(m_homeScreenToForeground);
+    
+    if (phoneVisible) { 
+        // Activate logs dialer only if telephone is on the top.
+        m_appLauncher->launchLogs(
+                XQService::LogsViewAll,
+                true,
+                QString::fromUtf16(
+                    entryContent->String()->Ptr(),
+                    entryContent->String()->Length()));
+    } 
+}
+
+void PhoneUIQtViewAdapter::setCommonButtonFlags()
+{
+    m_resourceAdapter->buttonsController()->setButtonFlags(
+            PhoneUIQtButtonsController::FullConference,
+            (5 <= m_bubbleWrapper->conferenceCallList().count()));
+
+    m_resourceAdapter->buttonsController()->setButtonFlags(
+            PhoneUIQtButtonsController::IhfAsPushButton,
+            m_speakerAsDefaultButton);
+}
+
+bool PhoneUIQtViewAdapter::convertKey(
+        TKeyCode symbianKey, Qt::Key &qtKey)
+{
+    bool ret = false;
+    
+    switch(symbianKey) {
+    case EKeyNo: {
+        qtKey = Qt::Key_No;
+        ret = true; 
+    }
+    break;
+    default:
+    break;
+    }
+    
+    return ret;
+}
+
+