phoneapp/phoneuiqtviewadapter/tsrc/ut_phoneuiqtviewadapter/phonecallheadermanager_stub.cpp
changeset 77 2be0b271d017
child 76 cfea66083b62
equal deleted inserted replaced
72:c76a0b1755b9 77:2be0b271d017
       
     1 /*!
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  Phone UI's symbian adapter for Qt view.
       
    15 *
       
    16 */
       
    17 
       
    18 #include "phonecallheadermanager.h"
       
    19 #include "phonecallheaderutil.h"
       
    20 #include "phoneuiqtviewif.h"
       
    21 #include "phonebubblewrapper.h"
       
    22 #include "tphonecmdparaminteger.h"
       
    23 #include "tphonecmdparamboolean.h"
       
    24 #include "tphonecmdparamaudioavailability.h"
       
    25 #include "tphonecmdparamaudiooutput.h"
       
    26 #include "tphonecmdparamcallstatedata.h"
       
    27 #include "tphonecmdparamcallheaderdata.h"
       
    28 #include "tphonecmdparamemergencycallheaderdata.h"
       
    29 #include "tphonecmdparamstring.h"
       
    30 #include "phonerssbase.h"
       
    31 
       
    32 bool m_createCallHeaderCalled;
       
    33 bool m_createEmergencyCallHeaderCalled;
       
    34 int m_createCallHeaderCallId;
       
    35 int m_updateCallHeaderCallId;
       
    36 int m_updateCallHeaderRemoteInfoCallId;
       
    37 int m_updateCallHeaderRemoteInfoAndLabelCallId;
       
    38 int m_handleCipheringInfoChangeCallId;
       
    39 int m_createConferenceBubbleCallId;
       
    40 bool m_removeAllCallHeadersCalled;
       
    41 bool m_removeConferenceBubbleCalled;
       
    42 int m_removeCallFromConferenceCallId;
       
    43 int m_setPrivateFromConferenceCallId;
       
    44 int m_removeCallHeaderCallId;
       
    45 bool m_isVoiceCall;
       
    46 
       
    47 #include <bubblemanagerif.h>
       
    48 #include <pevirtualengine.h>
       
    49 #include <mpeengineinfo.h>
       
    50 
       
    51 
       
    52 //CONSTANTS
       
    53 
       
    54 
       
    55 inline Qt::TextElideMode clipToElide(
       
    56     TPhoneCmdParamCallHeaderData::TPhoneTextClippingDirection clip)
       
    57     {
       
    58     return clip == TPhoneCmdParamCallHeaderData::ELeft ? 
       
    59                    Qt::ElideLeft : Qt::ElideRight;
       
    60     }
       
    61 
       
    62 PhoneCallHeaderManager::PhoneCallHeaderManager(PhoneBubbleWrapper &bubbleWrapper, 
       
    63         PhoneUIQtViewIF &view, QObject *parent) :
       
    64     QObject(parent),
       
    65     m_bubbleWrapper(bubbleWrapper),
       
    66     m_view(view),
       
    67     m_callHeaderUtil(0),
       
    68     m_resourceAdapter(0)
       
    69 {
       
    70     
       
    71 }
       
    72 
       
    73 PhoneCallHeaderManager::~PhoneCallHeaderManager ()
       
    74 {
       
    75     //delete m_callHeaderUtil;
       
    76 }
       
    77 
       
    78 
       
    79 
       
    80 void PhoneCallHeaderManager::setEngineInfo(MPEEngineInfo* engineInfo)
       
    81 {
       
    82     //m_engineInfo = engineInfo;
       
    83 }
       
    84 
       
    85 void PhoneCallHeaderManager::createCallHeader(
       
    86     int callId)
       
    87 {
       
    88     m_createCallHeaderCalled = true;
       
    89     m_createCallHeaderCallId = callId;
       
    90 }
       
    91 
       
    92 void PhoneCallHeaderManager::createEmergencyCallHeader(int callId)
       
    93 {
       
    94     m_createEmergencyCallHeaderCalled = true;
       
    95     m_createCallHeaderCallId = callId;
       
    96 }
       
    97 
       
    98 void PhoneCallHeaderManager::removeCallHeader(int callId)
       
    99 {
       
   100     m_removeCallHeaderCallId = callId;
       
   101 }
       
   102 
       
   103 void PhoneCallHeaderManager::updateCallHeaderState(int callId)
       
   104 {
       
   105     m_updateCallHeaderCallId = callId;
       
   106 }
       
   107 
       
   108 void PhoneCallHeaderManager::updateCallHeaderRemoteInfo(int callId)
       
   109 {
       
   110     m_updateCallHeaderRemoteInfoCallId = callId;
       
   111 }
       
   112 
       
   113 void PhoneCallHeaderManager::updateCallHeaderRemoteInfoAndLabel (int callId)
       
   114 {
       
   115     m_updateCallHeaderRemoteInfoAndLabelCallId = callId;
       
   116 }
       
   117 
       
   118 void PhoneCallHeaderManager::handleCipheringInfoChange(int callId)
       
   119 {
       
   120     m_handleCipheringInfoChangeCallId = callId;
       
   121 }
       
   122 
       
   123 
       
   124 void PhoneCallHeaderManager::createConferenceBubble(int callId)
       
   125 {
       
   126     m_createConferenceBubbleCallId = callId;;
       
   127 }
       
   128 
       
   129 
       
   130 void PhoneCallHeaderManager::removeConferenceBubble()
       
   131 {
       
   132     m_removeConferenceBubbleCalled = true;
       
   133 }
       
   134 
       
   135 void PhoneCallHeaderManager::removeCallFromConference(int callId)
       
   136 {
       
   137     m_removeCallFromConferenceCallId = callId;
       
   138 }
       
   139 
       
   140 
       
   141 void PhoneCallHeaderManager::setPrivateFromConference(int callId)
       
   142 {
       
   143     m_setPrivateFromConferenceCallId = callId;
       
   144 }
       
   145 
       
   146 
       
   147 void PhoneCallHeaderManager::setExpandedConferenceCallHeader()
       
   148 {
       
   149 
       
   150 }
       
   151 
       
   152 
       
   153 void PhoneCallHeaderManager::removeAllCallHeaders()
       
   154 {
       
   155     m_removeAllCallHeadersCalled = true;
       
   156 }
       
   157 
       
   158 // ---------------------------------------------------------------------------
       
   159 //  PhoneCallHeaderUtil::IsVoiceCall
       
   160 // ---------------------------------------------------------------------------
       
   161 //
       
   162 bool PhoneCallHeaderManager::isVoiceCall(int callId) const
       
   163     {
       
   164     return m_isVoiceCall;
       
   165     }
       
   166 
       
   167 // ---------------------------------------------------------------------------
       
   168 //  PhoneCallHeaderUtil::IsVideoCall
       
   169 // ---------------------------------------------------------------------------
       
   170 //
       
   171 bool PhoneCallHeaderManager::isVideoCall(int callId) const
       
   172     {
       
   173     return false;
       
   174     }
       
   175 
       
   176 bool PhoneCallHeaderManager::isIncoming(int callId) const
       
   177     {
       
   178     return false;
       
   179     }
       
   180 
       
   181 bool PhoneCallHeaderManager::isWaitingCall(int callId) const
       
   182     {
       
   183     bool waiting( EFalse );
       
   184 
       
   185     return waiting;
       
   186     }
       
   187 
       
   188 PhoneCallHeaderUtil *PhoneCallHeaderManager::callHeaderUtil()
       
   189 {
       
   190     /*if (!m_callHeaderUtil) {
       
   191         m_callHeaderUtil = new PhoneCallHeaderUtil(*m_engineInfo);
       
   192     }*/
       
   193 
       
   194     return 0;
       
   195 }
       
   196 
       
   197