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 #include "cphonemediatorfactory.h"

    32 #include "cphonemediatorsender.h"

    33 #include "phoneviewcommanddefinitions.h"

    34 

    35 #include <bubblemanagerif.h>

    36 #include <pevirtualengine.h>

    37 #include <mpeengineinfo.h>

    38 

    39 

    40 //CONSTANTS

    41 

    42 

    43 inline Qt::TextElideMode clipToElide(

    44     TPhoneCmdParamCallHeaderData::TPhoneTextClippingDirection clip)

    45     {

    46     return clip == TPhoneCmdParamCallHeaderData::ELeft ? 

    47                    Qt::ElideLeft : Qt::ElideRight;

    48     }

    49 

    50 PhoneCallHeaderManager::PhoneCallHeaderManager(PhoneBubbleWrapper &bubbleWrapper, 

    51         PhoneUIQtViewIF &view, QObject *parent) :

    52     QObject(parent),

    53     m_bubbleWrapper(bubbleWrapper),

    54     m_view(view),

    55     m_callHeaderUtil(0),

    56     m_resourceAdapter(0)

    57 {

    58     

    59 }

    60 

    61 PhoneCallHeaderManager::~PhoneCallHeaderManager ()

    62 {

    63     delete m_callHeaderUtil;

    64 }

    65 

    66 

    67 

    68 void PhoneCallHeaderManager::setEngineInfo(MPEEngineInfo* engineInfo)

    69 {

    70     m_engineInfo = engineInfo;

    71 }

    72 

    73 void PhoneCallHeaderManager::createCallHeader(

    74     int callId)

    75 {

    76     TPhoneCmdParamCallHeaderData data;

    77     

    78     if (isIncoming(callId)) {

    79         callHeaderUtil()->SetIncomingCallHeaderParams( 

    80                 callId, 

    81                 isWaitingCall(callId),

    82                 isVideoCall(callId),  

    83                 &data );

    84     } else {

    85         callHeaderUtil()->SetOutgoingCallHeaderParams(

    86                 callId,

    87                 &data);

    88     }

    89 

    90     m_bubbleWrapper.bubbleManager().startChanges ();

    91 

    92     if (m_bubbleWrapper.bubbleManager().isConferenceExpanded())

    93         {

    94         m_bubbleWrapper.bubbleManager().setExpandedConferenceCallHeader(false);

    95         }

    96 

    97     int bubble = m_bubbleWrapper.createCallHeader(callId);

    98     m_bubbleWrapper.setState(callId, bubble, data.CallState ());        

    99     m_bubbleWrapper.setCli(bubble, data.CLIText(), clipToElide(data.CLITextClippingDirection()));

   100     m_bubbleWrapper.setServiceId(callId, data.ServiceId());

   101     m_bubbleWrapper.setSecondaryCli(bubble, data.CNAPText (), clipToElide(data.CNAPTextClippingDirection()));

   102     m_bubbleWrapper.setLabel(bubble, data.LabelText ());

   103     m_bubbleWrapper.setCallType(bubble, data.CallType ());

   104     m_bubbleWrapper.setDivert(bubble, data.Diverted ());

   105     m_bubbleWrapper.setCiphering(bubble, data.CipheringIndicatorAllowed(), data.Ciphering());

   106 

   107     if (data.Picture().Length()) {

   108         QString imagePath =

   109             QString::fromUtf16(data.Picture().Ptr(),data.Picture().Length());

   110         m_bubbleWrapper.bubbleManager().setCallObjectImage(bubble,imagePath);

   111     } else {

   112         m_bubbleWrapper.bubbleManager().setCallObjectFromTheme(bubble);

   113     }

   114     m_bubbleWrapper.bubbleManager().endChanges ();

   115 

   116     CPhoneMediatorFactory::Instance()->Sender()->SendEvent(EPhoneViewCreateCallHeader, callId, data);

   117 }

   118 

   119 void PhoneCallHeaderManager::createEmergencyCallHeader(int callId)

   120 {

   121     m_bubbleWrapper.bubbleManager().startChanges ();

   122     int bubble = m_bubbleWrapper.createCallHeader (callId);

   123     m_bubbleWrapper.setLabel(bubble, callHeaderUtil()->AttemptingEmergencyText());

   124     m_bubbleWrapper.setCli (bubble, callHeaderUtil()->EmergencyHeaderText(), Qt::ElideRight);

   125     m_bubbleWrapper.setState(callId, bubble, EPEStateDialing);

   126     m_bubbleWrapper.setCiphering(bubble, m_engineInfo->SecureSpecified(), m_engineInfo->ServiceId(callId));

   127     m_bubbleWrapper.bubbleManager().endChanges ();

   128 

   129 }

   130 

   131 void PhoneCallHeaderManager::removeCallHeader(int callId)

   132 {

   133     m_bubbleWrapper.bubbleManager().startChanges();

   134     int bubble = m_bubbleWrapper.bubbles().value(callId, -1);

   135     if ( bubble != -1 ) {

   136         m_view.clearBubbleCommands(bubble);

   137         m_view.removeExpandAction(bubble);

   138         m_bubbleWrapper.removeCallHeader(callId);

   139     }

   140     m_bubbleWrapper.bubbleManager().endChanges();

   141 }

   142 

   143 void PhoneCallHeaderManager::updateCallHeaderState(int callId)

   144 {

   145 

   146     int bubble = m_bubbleWrapper.bubbleId(callId);

   147     if ( -1 != bubble ) {

   148         m_bubbleWrapper.bubbleManager ().startChanges ();

   149         m_bubbleWrapper.setState(callId, bubble, callHeaderUtil()->CallState(callId));

   150         m_bubbleWrapper.setLabel(bubble, callHeaderUtil()->LabelText(callId));

   151         m_bubbleWrapper.setDivert(bubble, m_engineInfo->IncomingCallForwarded(callId));

   152         m_bubbleWrapper.bubbleManager().endChanges ();

   153     }

   154 }

   155 

   156 void PhoneCallHeaderManager::updateCallHeaderRemoteInfo(int callId)

   157 {

   158 

   159     TPhoneCmdParamCallHeaderData data;

   160 

   161      int bubble = m_bubbleWrapper.bubbleId(callId);

   162      if ( -1 != bubble ) {

   163          callHeaderUtil()->UpdateCallHeaderInfo( 

   164                  callId, 

   165                  isWaitingCall(callId),

   166                  isVideoCall(callId),  

   167                  &data );

   168          

   169          m_bubbleWrapper.bubbleManager().startChanges();

   170          m_bubbleWrapper.setCli(bubble, data.CLIText(),

   171              clipToElide(data.CLITextClippingDirection()));

   172          m_bubbleWrapper.setSecondaryCli(bubble, data.CNAPText (),

   173              clipToElide(data.CNAPTextClippingDirection()));

   174          m_bubbleWrapper.setDivert(bubble, m_engineInfo->IncomingCallForwarded(callId));

   175          m_bubbleWrapper.bubbleManager().endChanges ();

   176      }

   177 

   178 }

   179 

   180 void PhoneCallHeaderManager::updateCallHeaderRemoteInfoAndLabel (int callId)

   181 {

   182     TPhoneCmdParamCallHeaderData data;

   183 

   184      int bubble = m_bubbleWrapper.bubbleId(callId);

   185      if ( -1 != bubble ) {

   186          callHeaderUtil()->UpdateCallHeaderInfo( 

   187                  callId, 

   188                  isWaitingCall(callId),

   189                  isVideoCall(callId),  

   190                  &data );

   191          

   192          m_bubbleWrapper.bubbleManager().startChanges ();

   193          m_bubbleWrapper.setCli(bubble, data.CLIText (),

   194              clipToElide(data.CLITextClippingDirection()));

   195          m_bubbleWrapper.setSecondaryCli(bubble, data.CNAPText (),

   196              clipToElide(data.CNAPTextClippingDirection()));

   197          m_bubbleWrapper.setLabel(bubble, data.LabelText ());

   198          m_bubbleWrapper.setDivert(bubble, data.Diverted ());

   199          m_bubbleWrapper.bubbleManager().endChanges ();

   200      }

   201 }

   202 

   203 void PhoneCallHeaderManager::handleCipheringInfoChange(int callId)

   204 {

   205     if (callId == KPEConferenceCallID) {

   206         bool secure(true);

   207         for (int i=0; i<m_bubbleWrapper.conferenceCallList().count(); i++) {

   208             if ( false == m_engineInfo->IsSecureCall(m_bubbleWrapper.conferenceCallList().at(i)) ) {

   209                 secure = false;

   210                 break;

   211             }

   212         }

   213         m_bubbleWrapper.bubbleManager().startChanges();

   214         m_bubbleWrapper.setCiphering(m_bubbleWrapper.bubbleId(callId),

   215                                      m_engineInfo->SecureSpecified(),

   216                                      secure);

   217         m_bubbleWrapper.bubbleManager().endChanges();

   218     } else {

   219         int bubble = m_bubbleWrapper.bubbleId(callId);        

   220         if ( -1 != bubble ) {        

   221             m_bubbleWrapper.bubbleManager().startChanges();

   222             m_bubbleWrapper.setCiphering(bubble,

   223                                          m_engineInfo->SecureSpecified(),

   224                                          m_engineInfo->IsSecureCall(callId));

   225             m_bubbleWrapper.bubbleManager().endChanges();

   226         }

   227     }

   228 }

   229 

   230 

   231 

   232 

   233 void PhoneCallHeaderManager::createConferenceBubble(int callId)

   234 {

   235     m_bubbleWrapper.bubbleManager().startChanges();

   236     TBuf<KPhoneCallHeaderLabelMaxLength> conferenceText( KNullDesC );

   237     callHeaderUtil()->LoadResource(conferenceText, EPhoneCLIConferenceCall);

   238     int bubble = m_bubbleWrapper.createConferenceBubble(

   239             callId, callHeaderUtil()->CallState(callId), callHeaderUtil()->LabelText(callId), conferenceText);

   240     

   241     m_bubbleWrapper.setServiceId(callId, m_engineInfo->ServiceId(callId));

   242     m_bubbleWrapper.setCiphering(bubble, m_engineInfo->SecureSpecified(), m_engineInfo->IsSecureCall(callId));

   243     m_bubbleWrapper.bubbleManager().endChanges();

   244 }

   245 

   246 

   247 void PhoneCallHeaderManager::removeConferenceBubble()

   248 {

   249     m_bubbleWrapper.bubbleManager().startChanges();

   250     m_view.removeExpandAction(m_bubbleWrapper.bubbleId(KConferenceCallId));

   251     m_view.clearParticipantListActions();

   252     m_bubbleWrapper.removeConferenceBubble();

   253     m_bubbleWrapper.bubbleManager().endChanges();

   254 }

   255 

   256 void PhoneCallHeaderManager::removeCallFromConference(int callId)

   257 {

   258     m_bubbleWrapper.bubbleManager().startChanges();

   259     m_bubbleWrapper.removeCallFromConference(callId);

   260     int bubbleId = m_bubbleWrapper.bubbles().value(callId);

   261     m_view.clearBubbleCommands(bubbleId);

   262     m_view.removeExpandAction(bubbleId);

   263     m_bubbleWrapper.removeCallHeader(callId);

   264     m_bubbleWrapper.bubbleManager().endChanges();

   265 }

   266 

   267 

   268 void PhoneCallHeaderManager::setPrivateFromConference(int callId)

   269 {

   270     m_bubbleWrapper.bubbleManager().startChanges();

   271     m_bubbleWrapper.bubbleManager().setExpandedConferenceCallHeader(false);

   272     m_bubbleWrapper.removeCallFromConference(callId);

   273     m_view.clearBubbleCommands(m_bubbleWrapper.bubbles().value(callId));

   274     m_bubbleWrapper.bubbleManager().endChanges();

   275 }

   276 

   277 

   278 void PhoneCallHeaderManager::setExpandedConferenceCallHeader()

   279 {

   280     int callId = -1;

   281 

   282     if ( 1==m_bubbleWrapper.bubbles().keys().size()

   283          || (1<m_bubbleWrapper.bubbles().keys().size()

   284          && false == m_bubbleWrapper.callStates().values().contains(EPEStateRinging)

   285          && false == m_bubbleWrapper.callStates().values().contains(EPEStateDialing)

   286          && false == m_bubbleWrapper.callStates().values().contains(EPEStateConnecting)

   287          && false == m_bubbleWrapper.callStates().values().contains(EPEStateHeldConference))) {

   288 

   289         int bubbleId = m_bubbleWrapper.bubbleManager().expandedBubble();

   290         callId = m_bubbleWrapper.callIdByBubbleId(bubbleId);

   291     }

   292 

   293     m_bubbleWrapper.bubbleManager().startChanges();

   294     m_bubbleWrapper.bubbleManager().setExpandedConferenceCallHeader(

   295             (KConferenceCallId == callId));

   296     m_bubbleWrapper.bubbleManager().endChanges();

   297 }

   298 

   299 

   300 void PhoneCallHeaderManager::removeAllCallHeaders()

   301 {

   302     if (m_bubbleWrapper.conferenceCallList().size()) {

   303         removeConferenceBubble();

   304     }

   305 

   306     QList<int> callIds = m_bubbleWrapper.bubbles().keys();

   307 

   308     for (int i=0; i<callIds.size(); ++i) {

   309         int callId = callIds.at(i);

   310         if (KEmergencyCallId != callId) {

   311             m_bubbleWrapper.bubbleManager().startChanges();

   312             int bubble = m_bubbleWrapper.bubbles().value(callId);

   313             m_view.clearBubbleCommands(bubble);

   314             m_view.removeExpandAction(bubble);

   315             m_bubbleWrapper.removeCallHeader (callId);

   316             m_bubbleWrapper.bubbleManager().endChanges();

   317         }

   318     }

   319 }

   320 

   321 // ---------------------------------------------------------------------------

   322 //  PhoneCallHeaderUtil::IsVoiceCall

   323 // ---------------------------------------------------------------------------

   324 //

   325 bool PhoneCallHeaderManager::isVoiceCall(int callId) const

   326     {

   327     if( callId < 0 )

   328         {

   329         return ( m_engineInfo->CallTypeCommand()

   330                     == EPECallTypeCSVoice ||

   331                 m_engineInfo->CallTypeCommand()

   332                     == EPECallTypeVoIP );  

   333         }

   334     

   335     return ( m_engineInfo->CallType( callId )

   336                 == EPECallTypeCSVoice ||

   337              m_engineInfo->CallType( callId )

   338                 == EPECallTypeVoIP );

   339     }

   340 

   341 

   342 // ---------------------------------------------------------------------------

   343 //  PhoneCallHeaderUtil::IsVideoCall

   344 // ---------------------------------------------------------------------------

   345 //

   346 bool PhoneCallHeaderManager::isVideoCall(int callId) const

   347     {

   348     if( callId < 0 )

   349         {

   350         return ( m_engineInfo->CallTypeCommand()

   351             == EPECallTypeVideo );  

   352         }

   353     return ( m_engineInfo->CallType( callId )

   354             == EPECallTypeVideo );

   355     }

   356 

   357 bool PhoneCallHeaderManager::isIncoming(int callId) const

   358     {

   359     return callId >= 0 && 

   360            m_engineInfo->CallState( callId ) == EPEStateRinging;

   361     }

   362 

   363 bool PhoneCallHeaderManager::isWaitingCall(int callId) const

   364     {

   365     bool waiting( EFalse );

   366     if ( callId >= 0 && 

   367          m_engineInfo->CallState( callId ) == EPEStateRinging )

   368         {

   369         if( m_bubbleWrapper.activeCallCount() > 0 )

   370             {

   371             waiting = ETrue;

   372             }

   373         }

   374     return waiting;

   375     }

   376 

   377 PhoneCallHeaderUtil *PhoneCallHeaderManager::callHeaderUtil()

   378 {

   379     if (!m_callHeaderUtil) {

   380         m_callHeaderUtil = new PhoneCallHeaderUtil(*m_engineInfo);

   381     }

   382 

   383     return m_callHeaderUtil;

   384 }

   385 

   386