1 /*

     2 * Copyright (c) 2002-2008 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:  This file contains the implementation of CPECallHandling class 

    15 *                member functions.

    16 *

    17 */

    18 

    19 

    20 // INCLUDE FILES

    21 #include    "cpecallhandling.h"

    22 #include    "cpevideocallhandling.h"

    23 #include    "cpesinglecall.h"

    24 #include    "cpedtmfhandling.h"

    25 #include    "cpesupplementaryservicesmonitor.h"

    26 #include    "mpephonemodelinternal.h"

    27 #include    "cpeconferencecall.h"

    28 #include    "cpecallarrayowner.h"

    29 #include    "mpecallhandling.h"

    30 #include    "cpecceobserver.h"

    31 #include    "cpesystemcallstate.h"

    32 

    33 #include    <gsmerror.h>

    34 #include    <mpedatastore.h>

    35 #include    <pepanic.pan>

    36 #include    <talogger.h>

    37 #include    <PSVariables.h>

    38 #include    <ctsydomainpskeys.h>

    39 #include    <mccecall.h>

    40 #include    <psetsaobserver.h>

    41 #include    <cccecallparameters.h>

    42 

    43 // EXTERNAL DATA STRUCTURES

    44 // None

    45 

    46 // EXTERNAL FUNCTION PROTOTYPES  

    47 // None

    48 

    49 // CONSTANTS

    50 // None

    51 

    52 // MACROS

    53 // None

    54 

    55 // LOCAL CONSTANTS AND MACROS

    56 

    57 // MODULE DATA STRUCTURES

    58 // None

    59 

    60 // LOCAL FUNCTION PROTOTYPES

    61 // None

    62 

    63 // FORWARD DECLARATIONS

    64 // None

    65 

    66 // ============================= LOCAL FUNCTIONS ===============================

    67 // None

    68 

    69 // ============================ MEMBER FUNCTIONS ===============================

    70 

    71 // -----------------------------------------------------------------------------

    72 // CPECallHandling::CPECallHandling

    73 // C++ default constructor can NOT contain any code, that

    74 // might leave.

    75 // -----------------------------------------------------------------------------

    76 //

    77 CPECallHandling::CPECallHandling(

    78     MPEPhoneModelInternal& aModel,

    79     CCCE& aConvergedCallEngine,

    80     MCCEDtmfInterface& aDtmfInterface

    81     ) : iModel( aModel ),

    82         iConvergedCallEngine( aConvergedCallEngine ),

    83         iDtmfInterface( aDtmfInterface ),

    84         iReplaceActive( EFalse ),

    85         iDialRequest( EFalse )

    86     {

    87     TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::CPECallHandling()");

    88     }

    89 

    90 // Destructor

    91 EXPORT_C CPECallHandling::~CPECallHandling()

    92     {  

    93     TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::~CPECallHandling() start");

    94     

    95     delete iSystemCallState;

    96     delete iDtmfHandling;

    97     

    98     // No need to uninitialize feature manager - this is done in MPEPhoneModelInternal .cpp

    99         

   100     delete iSupplementaryServicesMonitor;

   101     delete iCCEObserver;

   102 

   103     delete iVideoCallHandling;

   104     delete iConferenceCall;

   105     delete iCallArrayOwner;

   106     delete iPsetSAObserver;

   107     delete iCallOpenParams;

   108     

   109     TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::~CPECallHandling() complete");    

   110     }

   111 

   112 // -----------------------------------------------------------------------------

   113 // CPECallHandling::NewL

   114 // Two-phased constructor.

   115 // -----------------------------------------------------------------------------

   116 //

   117 EXPORT_C CPECallHandling* CPECallHandling::NewL(

   118         MPEPhoneModelInternal& aModel,                    

   119         CCCE& aConvergedCallEngine,

   120         MCCEDtmfInterface& aDtmfInterface )

   121     {

   122     TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::NewL start." );

   123     CPECallHandling* self = new (ELeave) CPECallHandling( aModel,

   124         aConvergedCallEngine, aDtmfInterface );

   125     CleanupStack::PushL( self );

   126     self->ConstructL();

   127     CleanupStack::Pop( self );

   128     TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::NewL complete." );

   129     return self;

   130     }

   131 

   132 // -----------------------------------------------------------------------------

   133 // CPECallHandling::ConstructL

   134 // Symbian 2nd phase constructor can leave.

   135 // -----------------------------------------------------------------------------

   136 //

   137 void CPECallHandling::ConstructL()

   138     {

   139     TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::BaseConstructL() start"); 

   140 

   141     // Creates a supplementary services monitor

   142     iSupplementaryServicesMonitor = new (ELeave) CPESupplementaryServicesMonitor( 

   143         *this, *iModel.DataStore() );

   144     

   145     iCCEObserver = CPECCEObserver::NewL( *this, iModel );

   146     

   147     iConvergedCallEngine.SetObserver( *iCCEObserver, *iSupplementaryServicesMonitor );

   148 

   149     // Creates CPEDtmfSender object

   150     iDtmfHandling = CPEDtmfHandling::NewL( *this, iDtmfInterface );

   151 

   152     // Creates a call array owner object

   153     iCallArrayOwner = CPECallArrayOwner::NewL( 

   154             iConvergedCallEngine, 

   155             *this );

   156     

   157     iVideoCallHandling = CPEVideoCallHandling::NewL( 

   158             *this, 

   159             iModel, 

   160             iConvergedCallEngine,

   161             *iCallArrayOwner );

   162                                                           

   163     iCallOpenParams = CCCECallParameters::NewL();

   164     

   165     iSystemCallState = CPESystemCallState::NewL( *iCallArrayOwner, *iModel.DataStore() );

   166     

   167     TEFLOGSTRING( KTAOBJECT, "CALL CPECallHandling::BaseConstructL() complete");

   168     }

   169 

   170 // -----------------------------------------------------------------------------

   171 // CPECallHandling::SendErrorMessage

   172 // Reroutes error messages to the Phone Engine, usable by other than call objects

   173 // -----------------------------------------------------------------------------

   174 //

   175 void CPECallHandling::SendErrorMessage(

   176         const TInt aErrorCode )

   177     {

   178     TEFLOGSTRING2( KTAINT, 

   179         "CALL CPECallHandling::SendErrorMessage, error code: %d", 

   180         aErrorCode );

   181 

   182     iModel.DataStore()->SetErrorCode( aErrorCode );

   183     iModel.SendMessage( MEngineMonitor::EPEMessageCallHandlingError );

   184     }

   185 

   186 // -----------------------------------------------------------------------------

   187 // CPECallHandling::SendErrorMessage

   188 // Reroutes error messages to the Phone Engine, usable by call objects

   189 // -----------------------------------------------------------------------------

   190 //

   191 void CPECallHandling::SendErrorMessage( 

   192         const TInt aCallId,

   193         const TInt aErrorCode )

   194     {

   195     TEFLOGSTRING3( KTAINT, 

   196         "CALL CPECallHandling::SendErrorMessage, error code: %d, call id: %d", 

   197         aErrorCode,

   198         aCallId );

   199     

   200     // Dial request failed - resume held call

   201     if( aErrorCode == ECCPErrorInvalidFDN )

   202         {

   203         HandleAutoResume();

   204         }

   205 

   206     if ( aCallId == KPECallIdNotUsed )

   207         {

   208         SendErrorMessage( aErrorCode );

   209         }

   210     else

   211         {

   212         iModel.DataStore()->SetErrorCode( aErrorCode );

   213         iModel.SendMessage( MEngineMonitor::EPEMessageCallHandlingError, aCallId );

   214         

   215         //Handle call objet deleting if dialing fail.

   216         if( ECCPErrorNone != aErrorCode )

   217             {

   218             CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

   219             if( callData )

   220                 {

   221                 TEFLOGSTRING2( KTAINT, 

   222                     "CALL CPECallHandling::SendErrorMessage, call state %d", callData->GetCallState() );

   223                 if( callData->GetCallState() == EPEStateIdle )

   224                     {

   225                     ReleaseCallObject( aCallId  );

   226                     iDialRequest = EFalse;

   227                     }

   228                 }

   229             }

   230 

   231         if( ( KPEConferenceCallID == aCallId ) && ( ECCPConferenceErrorAddCall == aErrorCode ) &&

   232               iConferenceCall && ( iConferenceCall->EnumerateCalls() == 0 ) )

   233            { 

   234            delete iConferenceCall; 

   235            iConferenceCall = NULL;

   236            iModel.DataStore()->ResetCallInfo( aCallId );

   237            } 

   238         }

   239     }

   240 

   241 // -----------------------------------------------------------------------------

   242 // CPECallHandling::SendMessage

   243 // Reroutes messages to the Phone Engine, usable by other than call objects

   244 // -----------------------------------------------------------------------------

   245 //

   246 void CPECallHandling::SendMessage( 

   247     MEngineMonitor::TPEMessagesFromPhoneEngine aMessage )

   248     {

   249     TEFLOGSTRING2( KTAINT,

   250         "CALL CPECallHandling::SendMessage, message id: %d", aMessage );

   251    

   252     iModel.SendMessage( aMessage );

   253     }

   254 

   255 // -----------------------------------------------------------------------------

   256 // CPECallHandling::SendMessage

   257 // Reroutes messages to the Phone Engine, usable by call objects

   258 // -----------------------------------------------------------------------------

   259 //

   260 void CPECallHandling::SendMessage( 

   261     MEngineMonitor::TPEMessagesFromPhoneEngine aMessage,

   262     TInt aCallId )

   263     {

   264     TEFLOGSTRING3( KTAINT, 

   265         "CALL CPECallHandling::SendMessage, message id: %d, call id: %d", 

   266         aMessage, 

   267         aCallId );

   268     

   269     TInt errorCode( KErrNone );

   270     

   271     switch ( aMessage )

   272         {

   273         case MEngineMonitor::EPEMessageDialing:

   274             {

   275             iDialRequest = EFalse;

   276             CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

   277             if( callData )

   278                 {

   279                 MCCECall& call = callData->Call();

   280                 iModel.DataStore()->SetCallIndex(call.CallIndex(), aCallId );                

   281                 SetCallOrigin( aCallId, call );                        

   282                 }  

   283             break;

   284             }

   285         case MEngineMonitor::EPEMessageChangedCallDuration:

   286             {

   287             TTimeIntervalSeconds duration;

   288  

   289             errorCode = GetCallDuration( duration, aCallId );

   290             if ( errorCode == KErrNone )

   291                 {

   292                 iModel.DataStore()->SetCallDuration( duration, aCallId );

   293                 }

   294             break;

   295             }

   296         case MEngineMonitor::EPEMessageIdle:

   297             {

   298             HandleAutoResume();

   299             break;

   300             }

   301         case MEngineMonitor::EPEMessageAddedConferenceMember:

   302             {

   303             TName memberName;

   304             TInt count;

   305 

   306             errorCode = GetNumberOfParticipants( count );

   307             TEFLOGSTRING2( 

   308                 KTAMESIN, 

   309                 "CALL CPECallHandling::SendMessage EPEMessageAddedConferenceMember errorCode %d", 

   310                 errorCode );

   311             if ( errorCode == KErrNone )

   312                 {

   313                 iModel.DataStore()->SetNumberOfConferenceMembers( count, KPEConferenceCallID );

   314 

   315                 iConferenceCall->GetConferenceMemberName( memberName );

   316 

   317                 if ( errorCode == KErrNone )

   318                     {

   319                     iModel.DataStore()->SetConferenceMemberInfo( 

   320                         memberName, 

   321                         KPEConferenceCallID, 

   322                         aCallId );

   323                     iModel.DataStore()->SetCallConference( aCallId, 

   324                             KPEConferenceCallID );

   325                     }

   326                 }

   327             break;

   328             }

   329         case MEngineMonitor::EPEMessageDroppedConferenceMember:                

   330             {

   331             TName memberName;

   332             TInt memberCallId;

   333             TInt count;

   334 

   335             errorCode = GetNumberOfParticipants( count );

   336             TEFLOGSTRING2( 

   337                 KTAMESIN, 

   338                 "CALL CPECallHandling::SendMessage EPEMessageAddedConferenceMember EPEMessageDroppedConferenceMember %d", 

   339                 errorCode );

   340             if ( errorCode == KErrNone )

   341                 {

   342                 iModel.DataStore()->SetNumberOfConferenceMembers( count, KPEConferenceCallID );

   343 

   344                 errorCode = GetConferenceMemberNameAndId( memberName, 

   345                                                           memberCallId );

   346 

   347                 // Member has been taken to OneToOne conversation and is still alive

   348                 if ( errorCode == KErrNone )

   349                     {

   350                     iModel.DataStore()->SetConferenceMemberInfo( 

   351                         memberName, 

   352                         KPECallIdNotUsed, 

   353                         aCallId );

   354                     iModel.DataStore()->SetCallConference( 

   355                         KPENormalVoiceCall,

   356                         memberCallId );

   357                     }

   358                 else

   359                     {

   360                     // Member has been dropped and its state is idle, so no 

   361                     // information can be found...

   362                     // So actually not an error situation memberName is empty

   363                     // (set in GetConferenceMemberNameAndId method) 

   364                     iModel.DataStore()->SetConferenceMemberInfo( 

   365                         memberName, 

   366                         KPECallIdNotUsed, 

   367                         aCallId );

   368                     errorCode = KErrNone;

   369                     }

   370                 }                

   371             break;    

   372             }

   373         case MEngineMonitor::EPEMessageCallControlCapsChanged: 

   374             {

   375             TPECallControlCaps callControlCaps;

   376             errorCode = GetCallControlCaps( callControlCaps, aCallId );

   377             if ( errorCode == KErrNone )

   378                 {

   379                 iModel.DataStore()->SetCallControlCaps( 

   380                     callControlCaps, 

   381                     aCallId );

   382                 }

   383             break;

   384             }

   385         case MEngineMonitor::EPEMessageConferenceCapsChange:                             

   386             {

   387             TUint32 caps;

   388             errorCode = GetConferenceCallCaps( caps );

   389             if ( errorCode == KErrNone )

   390                 {

   391                 iModel.DataStore()->SetConferenceCallCaps( caps, aCallId );

   392                 }

   393             break;    

   394             }

   395         case MEngineMonitor::EPEMessageDisconnecting:

   396             {

   397             CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

   398             if ( callData )

   399                 {

   400                 TCCPTone inbandTone = callData->Tone();

   401                 iModel.DataStore()->SetInbandTone( inbandTone );

   402                 }

   403             break;

   404             }

   405         case MEngineMonitor::EPEMessageConferenceErrorAddCall:

   406         case MEngineMonitor::EPEMessageConferenceErrorRemoveCall:

   407         case MEngineMonitor::EPEMessageConferenceErrorSwap:

   408         case MEngineMonitor::EPEMessageConferenceErrorHold:

   409         case MEngineMonitor::EPEMessageConferenceErrorResume:

   410         case MEngineMonitor::EPEMessageConferenceErrorGoOneToOne:

   411         case MEngineMonitor::EPEMessageConferenceErrorCurrentCallsToConference:

   412             {

   413             errorCode = KErrGeneral;

   414             if( iConferenceCall && ( iConferenceCall->EnumerateCalls() == 0 ) )

   415                 {

   416                 delete iConferenceCall;

   417                 iConferenceCall = NULL;

   418                 }

   419             break;

   420             }

   421         case MEngineMonitor::EPEMessageCallSecureStatusChanged:

   422             {

   423             iModel.DataStore()->SetCallSecureStatus( 

   424                 IsSecureCall( aCallId ), 

   425                 aCallId );

   426             // Secure is specified  

   427             iModel.DataStore()->SetSecureSpecified( ETrue );

   428             break;

   429             }          

   430         case MEngineMonitor::EPEMessageSecureNotSpecified:

   431             {

   432             iModel.DataStore()->SetSecureSpecified( EFalse );

   433             break;

   434             }                     

   435             

   436         case MEngineMonitor::EPEMessageRemotePartyInfoChanged:

   437             {

   438             TEFLOGSTRING( KTAMESINT, "CALL CPECallHandling::SendMessage -> EPEMessageRemotePartyInfoChanged");

   439             // HO cases call type can changes

   440             CPESingleCall* connectedCall;

   441             connectedCall = iCallArrayOwner->CallPointerByState( EPEStateConnected );

   442             

   443             if( connectedCall )

   444                 {

   445                 CCPCall::TCallType callType = connectedCall->Call().Parameters().CallType();

   446                 

   447                 if ( callType == CCPCall::ECallTypePS ) 

   448                     {

   449                     TEFLOGSTRING( KTAMESINT, 

   450                         "CALL CPECallHandling::SendMessage -> EPEMessageRemotePartyInfoChanged->update call type to PS");

   451                     iModel.DataStore()->SetCallType( EPECallTypeVoIP, aCallId ); 

   452                     iModel.DataStore()->SetServiceIdCommand( connectedCall->Call().Parameters().ServiceId() );

   453                     iCallOpenParams->SetCallType( CCPCall::ECallTypePS); 

   454                     }

   455                 else if ( callType == CCPCall::ECallTypeCSVoice )

   456                     {

   457                      TEFLOGSTRING( KTAMESINT, 

   458                         "CALL CPECallHandling::SendMessage -> EPEMessageRemotePartyInfoChanged->update call type to CS");

   459                     iCallOpenParams->SetCallType( CCPCall::ECallTypeCSVoice );

   460                     iModel.DataStore()->SetServiceIdCommand( 1 );

   461                     iModel.DataStore()->SetCallType( EPECallTypeCSVoice, aCallId );    

   462                     }

   463                 }

   464             }

   465        // Flow throught

   466             

   467         case MEngineMonitor::EPEMessageIncoming:

   468             {

   469             CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

   470             if( callData )

   471                 {

   472                 MCCECall& call = callData->Call();

   473                 iModel.DataStore()->SetRemotePartyName( call.RemotePartyName(), aCallId );

   474                 iModel.DataStore()->SetRemotePhoneNumber( call.RemoteParty().Left( KPEPhoneNumberMaxLength ), aCallId );

   475                 iModel.DataStore()->SetCallIndex(call.CallIndex(), aCallId );

   476                 }

   477             break;

   478             }

   479         case MEngineMonitor::EPEMessageForwardUnconditionalModeActive:

   480             {

   481             UpdateSaSetting();

   482             break;

   483             }

   484         case MEngineMonitor::EPEMessageUnattendedTransferRequest:

   485             {

   486             CPESingleCall* call = iCallArrayOwner->GetCallObject( aCallId );

   487             __ASSERT_DEBUG( NULL != call, Panic( EPEPanicIllegalCommand ) );

   488             if ( call )

   489                 {

   490                 iModel.DataStore()->SetUnattendedTransferTarget( 

   491                     call->UnattendedTransferTarget(), aCallId );

   492                 }

   493             

   494             break;

   495             }

   496         case MEngineMonitor::EPEMessageALSLineChanged:

   497             {

   498             SetActiveLine();

   499             break;

   500             }

   501         case MEngineMonitor::EPEMessageMovedPermanently:

   502         case MEngineMonitor::EPEMessageMultipleChoices:

   503             {

   504             /* Incoming moved permanently request from server,

   505              * store target addresses for later use

   506              */

   507             CPESingleCall* call = iCallArrayOwner->GetCallObject( aCallId );

   508             __ASSERT_DEBUG( NULL != call, Panic( EPEPanicIllegalCommand ) );

   509             if ( call )

   510                 {

   511                 iModel.DataStore()->SetForwardAddressChoices( 

   512                     call->ForwardAddressChoices(), aCallId );

   513                 }

   514             

   515             break;

   516             }

   517         default:

   518             // Other messages cause no action.

   519             break;

   520         } 

   521 

   522     if( aCallId != KPECallIdNotUsed )

   523         {

   524         // Preferred to be before sendmessage

   525         // f.e active idle update before display to screen

   526         iSystemCallState->NotifySystemCallStateChanged( aMessage, aCallId );

   527         }

   528     

   529     if ( errorCode )

   530         {

   531         SendErrorMessage( aCallId, errorCode );

   532         }

   533     else

   534         {

   535         iModel.SendMessage( aMessage, aCallId );

   536         }

   537 

   538     // Call obect deleting in idle state is handled here because phoneengine 

   539     // uses call object during idle state handling

   540     if( aMessage == MEngineMonitor::EPEMessageIdle )

   541         {

   542         TEFLOGSTRING2( KTAINT, 

   543            "CALL CPECallHandling::SendMessage DeleteCallObject %d", aCallId );

   544         iCallArrayOwner->DeleteCallObject( aCallId );

   545         }

   546     else if( aMessage == MEngineMonitor::EPEMessageConferenceIdle )

   547         {

   548         delete iConferenceCall;

   549         iConferenceCall = NULL;

   550         if ( iReplaceActive )

   551             {

   552             AnswerCall();

   553             iReplaceActive = EFalse;

   554             }

   555         }

   556     }

   557 

   558 // -----------------------------------------------------------------------------

   559 // CPECallHandling::AnswerCall

   560 // Answers an incoming call

   561 // -----------------------------------------------------------------------------

   562 //

   563 EXPORT_C TInt CPECallHandling::AnswerCall()

   564     {

   565     TEFLOGSTRING( KTAMESINT, "CALL CPECallHandling::AnswerCall");

   566     TInt callIndex;

   567     CPESingleCall* callData;

   568     CPESingleCall* connectedCall;

   569     TInt errorCode( ECCPErrorNotFound );

   570 

   571     callData = VoiceCallDataByState( EPEStateRinging, callIndex );

   572     connectedCall = iCallArrayOwner->CallPointerByState( EPEStateConnected );

   573     if( connectedCall && !iReplaceActive )

   574         {

   575         CCPCall::TCallType callType = connectedCall->Call().Parameters().CallType();

   576         TEFLOGSTRING2( KTAINT, 

   577             "CALL CPECallHandling::AnswerCall EPEStateConnected type %d", callType );

   578         if( callType == CCPCall::ECallTypeVideo )

   579             {

   580             TEFLOGSTRING( KTAINT, 

   581                 "CALL CPECallHandling::AnswerCall ECCPErrorNotAllowed" );

   582             return ECCPErrorNotAllowed;

   583             }

   584         }

   585         

   586     if ( callData )

   587         {

   588         TEFLOGSTRING2( KTAINT, 

   589             "CALL CPECallHandling::AnswerCall > CPESingleCall::Answer %d", 

   590             callData->GetCallId() );

   591         errorCode = callData->Answer();        

   592         }

   593     else

   594         {

   595         TEFLOGSTRING( KTAINT, 

   596             "CALL CPECallHandling::AnswerCall > iVideoCallHandling->AnswerCall");

   597         errorCode = iVideoCallHandling->AnswerCall();

   598         }

   599         

   600     return errorCode;

   601     }

   602 

   603 // -----------------------------------------------------------------------------

   604 // CPECallHandling::DialCall

   605 // creates dial request to the CPESingleCall object

   606 // -----------------------------------------------------------------------------

   607 //

   608 EXPORT_C TInt CPECallHandling::DialCall( 

   609     const TPEPhoneNumber& aNumber,

   610     TInt& aCallId )

   611     {

   612     TEFLOGSTRING( KTAINT, "CALL CPECallHandling::DialCall" );

   613     CPESingleCall* callData( NULL );

   614     TInt errorCode( KErrNone );

   615 

   616     // If there is allready video call, one dial in connecting, dialing or disconnecting state,

   617     // we just ignore new dial request and send KErrInUse back to UI

   618     if( iDialRequest )

   619         {

   620         // Dial request already send, waiting for dialing state.

   621         errorCode = KErrGeneral;

   622         TEFLOGSTRING( KTAERROR, 

   623             "CALL CPECALLHANDLING::DIALCALL ! DIAL FAILED: DIAL REQUEST ALREADY ACTIVE" );

   624         }

   625     else if ( IsDialAllowed ( EFalse ) )

   626         {

   627         // Set user to user info call params.

   628                 // Set user to user info call params.

   629                 

   630         const CCCECallParameters& params = iModel.DataStore()->CallParameters();

   631         iCallOpenParams->SetBearer( params.Bearer() );

   632         iCallOpenParams->SetSubAddress( params.SubAddress() );

   633         iCallOpenParams->SetOrigin( params.Origin() );

   634         iCallOpenParams->SetUUSId( iModel.DataStore()->UserToUserInformation() );

   635         

   636         TRAP( errorCode, callData = OpenNewCallL( aNumber ) );

   637         if( errorCode == KErrNone )

   638             {

   639             if( iModel.DataStore()->CallOriginCommand() == EPECallOriginSAT )

   640                 {

   641                 // disable number matching for SAT calls

   642                 callData->DisableFDNCheck();

   643                 }

   644             

   645             TEFLOGSTRING( KTAINT, "CALL CPECallHandling::DialCall > Dial" );

   646             iDialRequest = ETrue;

   647             errorCode = callData->Dial( aNumber );

   648             

   649             if ( errorCode != KErrNone )

   650                 {

   651                 iDialRequest = EFalse;

   652                 // Dial failed: clean up

   653                 ReleaseCallObject( callData->GetCallId() );

   654                 TEFLOGSTRING2( KTAERROR, 

   655                     "CALL CPECALLHANDLING::DIALCALL ! DIAL FAILED: MAY NOT PROCEED! %d", errorCode );

   656                 }

   657             else

   658                 {

   659                 // Dial request passed on successfully: forward new call id

   660                 aCallId = callData->GetCallId();

   661                 }

   662             }

   663         }

   664     else

   665         {

   666         errorCode = KErrInUse;

   667         }

   668         

   669     return errorCode;

   670     }

   671 

   672 // -----------------------------------------------------------------------------

   673 // CPECallHandling::DialMultimedia

   674 // creates dial request to the CPESingleCall object

   675 // -----------------------------------------------------------------------------

   676 //

   677 EXPORT_C TInt CPECallHandling::DialMultimedia( 

   678         const TPEPhoneNumber& aNumber,

   679         TInt& aCallId

   680         )

   681     {

   682     TEFLOGSTRING( KTAMESINT, "CALL CPECallHandling::DialMultimedia");

   683     TInt errorCode( ECCPErrorNone );

   684     

   685     // If there is allready call, one dial in connecting, dialing or disconnecting state,

   686     // we just ignore new dial request and send KErrInUse back to UI    

   687     if ( IsDialAllowed ( ETrue ) )

   688         {

   689         errorCode = iVideoCallHandling->DialCall( aNumber, aCallId );

   690         }

   691     else

   692         {

   693         errorCode = ECCPErrorAlreadyInUse;

   694         }

   695     return errorCode;

   696     }

   697 // -----------------------------------------------------------------------------

   698 // CPECallHandling::IsDialAllowed

   699 //  

   700 // -----------------------------------------------------------------------------

   701 //

   702 TBool CPECallHandling::IsDialAllowed( TBool aMultimediaDial )

   703     {

   704     TEFLOGSTRING( KTAMESINT, "CALL CPECallHandling::IsDialAllowed");

   705     

   706     CPESingleCall* call = iCallArrayOwner->CallPointerByState( EPEStateConnected );

   707     CPESingleCall* heldCall = iCallArrayOwner->CallPointerByState( EPEStateHeld );

   708     

   709     TBool status = EFalse;

   710     

   711     if( ( call || heldCall ) && aMultimediaDial )

   712         {

   713         // A call was found when tried video call

   714         TEFLOGSTRING( KTAERROR, 

   715             "CALL CPECALLHANDLING::IsDialAllowed() CANNOT CREATE A VIDEO CALL IN CALL STATE!");

   716         }

   717     else if( call && iVideoCallHandling->IsMultimedia( call->GetCallId() ) )

   718         {

   719         // A video call was found when tried voice or video call

   720         TEFLOGSTRING( KTAERROR, 

   721             "CALL CPECALLHANDLING::IsDialAllowed() CANNOT CREATE A CALL IN VIDEO CALL STATE!");

   722         }

   723     else if( iCallArrayOwner->CallPointerByState( EPEStateDialing ) ) 

   724         {

   725         // A dialing call was found

   726             TEFLOGSTRING( KTAERROR, 

   727                 "CALL CPECALLHANDLING::IsDialAllowed() CANNOT CREATE A CALL IN DIALING STATE!");

   728          }

   729     else if( iCallArrayOwner->CallPointerByState( EPEStateConnecting ) ) 

   730         { 

   731         // A connecting call was found

   732          TEFLOGSTRING( KTAERROR, 

   733              "CALL CPECALLHANDLING::IsDialAllowed() CANNOT CREATE A CALL IN CONNECTING STATE!");

   734 

   735         }

   736     else if( iCallArrayOwner->CallPointerByState( EPEStateDisconnecting ) ) 

   737         {

   738         // A disconnecting call was found

   739         TEFLOGSTRING( KTAERROR, 

   740             "CALL CPECALLHANDLING::IsDialAllowed() CANNOT CREATE A CALL IN DISCONNECTING STATE!");

   741          }

   742     else if( ( iConferenceCall && iConferenceCall->GetCallState() == EPEStateConnectedConference && ( heldCall ) ) ||

   743             ( iConferenceCall && iConferenceCall->GetCallState() == EPEStateHeldConference && ( call ) ) )

   744         {

   745         // coference and single call found

   746         TEFLOGSTRING( KTAERROR, 

   747             "CALL CPECALLHANDLING::IsDialAllowed() CANNOT CREATE A CALL IN CONFERENCE AND SINGLE STATE!");

   748         }

   749     else

   750         {

   751         status = ETrue; // Dial allowed

   752         }

   753     return status; 

   754     }

   755 

   756 // -----------------------------------------------------------------------------

   757 // CPECallHandling::HangUp

   758 // Terminates an ongoing call

   759 // -----------------------------------------------------------------------------

   760 //

   761 EXPORT_C TInt  CPECallHandling::HangUp( 

   762         TInt aCallId, 

   763         TPEHangUpOptions aAutoResumeOption )

   764     {

   765     TEFLOGSTRING3( KTAMESINT, "CALL CPECallHandling::HangUp aCallId= %d aAutoResumeOption= %d ", aCallId, aAutoResumeOption );

   766     TInt errorCode( ECCPErrorNotFound );

   767     

   768     CPESingleCall* heldcall = iCallArrayOwner->CallPointerByState( EPEStateHeld );

   769 

   770     if( aAutoResumeOption == ETPEHangUpResumeHeldCall )

   771         {

   772         if( heldcall )

   773             {

   774             iModel.DataStore()->SetResumeHeldCall( ETrue, heldcall->GetCallId() );

   775             }

   776         else if( iConferenceCall && ( iConferenceCall->GetCallState() == EPEStateHeldConference ) )

   777             {

   778             iModel.DataStore()->SetResumeHeldCall( ETrue, KPEConferenceCallID );

   779             }

   780         }

   781     else if( aAutoResumeOption == ETPEHangUpNotResumeHeldCall )

   782         {

   783         if( heldcall )

   784             {

   785             iModel.DataStore()->SetResumeHeldCall( EFalse, heldcall->GetCallId() );

   786             }

   787         else if( iConferenceCall && ( iConferenceCall->GetCallState() == EPEStateHeldConference ) )

   788             {

   789             iModel.DataStore()->SetResumeHeldCall( EFalse, KPEConferenceCallID );

   790             }

   791         }

   792 

   793     if ( CallIdCheck::IsVoice( aCallId )) 

   794         {

   795         CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

   796         if( callData )

   797             {

   798             // conference call that is not yet created, must be cancelled.

   799             if( iConferenceCall && iConferenceCall->GetCallState() == EPEStateCreatingConference )

   800                 {

   801                 TEFLOGSTRING( KTAERROR, 

   802                     "CPECallHandling::HangUp Delete conference call.");

   803                 delete iConferenceCall;

   804                 iConferenceCall = NULL;

   805                 }

   806             

   807             errorCode = callData->HangUp();

   808             }

   809         else

   810             {

   811             TEFLOGSTRING( KTAERROR, 

   812                 "CALL CPECALLHANDLING::HANGUP ! CALL OBJECT IN IDLE STATE OR ALREADY HANGING UP" );

   813             }

   814         }

   815 

   816     else if ( CallIdCheck::IsVideo( aCallId ) ) 

   817         {

   818         errorCode = iVideoCallHandling->HangUp( aCallId );

   819         }

   820 

   821     else if ( CallIdCheck::IsConference( aCallId ) )

   822         {

   823         if( iConferenceCall )

   824             {

   825             errorCode = iConferenceCall->HangUp();

   826             }

   827         }

   828     return errorCode;

   829     }

   830 

   831 // -----------------------------------------------------------------------------

   832 // CPECallHandling::TerminateAllConnections

   833 // Terminates all ringing voice and data calls

   834 // -----------------------------------------------------------------------------

   835 //

   836 EXPORT_C TInt CPECallHandling::TerminateAllConnections()

   837     {

   838     CPESingleCall* callData;

   839     TPEState callState;

   840 

   841     TEFLOGSTRING( KTAMESINT, "CALL CPECallHandling::TerminateAllConnections");

   842     

   843     RejectCall(); // Rejects ringing call if one exists.

   844 

   845     if ( iConferenceCall )

   846         {

   847         TEFLOGSTRING( KTAMESOUT, 

   848             "CALL CPECallHandling::TerminateAllConnections: Hanging Up conference call" );

   849         iConferenceCall->HangUp();

   850         }

   851             

   852     // Hangup normal Voice Calls

   853     for( TInt callId = 0; callId < KPEMaximumNumberOfVoiceCalls; callId++ )

   854         {

   855         callData = iCallArrayOwner->GetCallObject( callId );

   856         if( callData )

   857             {

   858             callState = callData->GetCallState();

   859             if ( callState != EPEStateIdle ) 

   860                 {

   861                 TEFLOGSTRING2( KTAREQOUT, 

   862                     "CALL CPECallHandling::TerminateAllConnections: Hanging Up call id %d...", 

   863                     callId );

   864                 callData->HangUp();

   865                 }

   866             }

   867         }

   868     //Terminate all ringing data calls, connected data calls and packet data connections

   869     return iVideoCallHandling->TerminateAllConnections();

   870     }

   871 

   872 // -----------------------------------------------------------------------------

   873 // CPECallHandling::UpdatePhoneIdentity

   874 // Method updates phone identity

   875 // -----------------------------------------------------------------------------

   876 //

   877 EXPORT_C TInt CPECallHandling::UpdatePhoneIdentity(

   878     MEngineMonitor::TPEMessagesFromPhoneEngine /*aMessage*/ )

   879     {

   880     TInt retValue( KErrNone ); 

   881     CSInfo csinfo;

   882     retValue = iConvergedCallEngine.GetCSInfo( csinfo );

   883     

   884     TPEPhoneIdentityParameters phoneIdentityParameters;

   885     

   886     phoneIdentityParameters.iSerialNumber = csinfo.iSerialNumber;

   887         

   888     iModel.DataStore()->SetPhoneIdentityParameters( phoneIdentityParameters );

   889 

   890     SendMessage( MEngineMonitor::EPEMessageShowIMEI );

   891     return retValue;

   892     }

   893 

   894 // -----------------------------------------------------------------------------

   895 // CPECallHandling::IsCallInState

   896 // returns ETrue if there is a call in given state; otherwise EFalse

   897 // -----------------------------------------------------------------------------

   898 //

   899 EXPORT_C TBool CPECallHandling::IsCallInState( TPEState aState ) const

   900     {

   901     TBool isCallInState( EFalse );

   902     iCallArrayOwner->CallPointerByState( aState ) ? isCallInState = ETrue : isCallInState = EFalse;

   903     

   904     return isCallInState;

   905     }

   906 

   907 // -----------------------------------------------------------------------------

   908 // CPECallHandling::GetCallIdByState

   909 // returns return callid is there is a call; otherwise KPECallIdNotUsed( -1 ).

   910 // -----------------------------------------------------------------------------

   911 //

   912 EXPORT_C TInt CPECallHandling::GetCallIdByState( TPEState aState ) const

   913     {

   914     TInt callId( KPECallIdNotUsed );

   915     CPESingleCall* call = iCallArrayOwner->CallPointerByState( aState );

   916     if( call )

   917         {

   918         callId = call->GetCallId();

   919         }

   920     TEFLOGSTRING2( KTAREQOUT, 

   921                    "CALL CPECallHandling::GetCallIdByState: callid %d", 

   922                    callId );

   923     return callId;

   924     }

   925     

   926 // -----------------------------------------------------------------------------

   927 // CPECallHandling::GetMissedCall

   928 // Returns the missed voice call indicator.

   929 // Method checks that call id is valid number

   930 // Method gets CPECallData object from the CArrayPtrFlat and

   931 // Method gets the missed voice call indicator from CPECallData object

   932 // -----------------------------------------------------------------------------

   933 //

   934 EXPORT_C TInt CPECallHandling::GetMissedCall( 

   935         TBool& aMissedCall,

   936         TInt aCallId )

   937     {

   938     TInt errorCode( ECCPErrorNotFound );

   939 

   940     CPESingleCall* voiceCall = iCallArrayOwner->GetCallObject( aCallId );

   941     if( voiceCall )

   942         {

   943         errorCode = voiceCall->GetMissedCall( aMissedCall );

   944         }

   945     else

   946         {

   947         __ASSERT_DEBUG( EFalse, Panic( EPEPanicIllegalCommand) );

   948         }

   949 

   950     return errorCode;

   951     }

   952     

   953 // -----------------------------------------------------------------------------

   954 // CPECallHandling::GetCallInfo

   955 // Returns call info

   956 // -----------------------------------------------------------------------------

   957 //

   958 EXPORT_C TInt CPECallHandling::GetCallInfo( 

   959     RMobileCall::TMobileCallInfoV3& aCallInfo,

   960     TInt aCallId )

   961     {

   962     CPESingleCall* callData;

   963     TInt errorCode( ECCPErrorNotFound );

   964 

   965     if ( CallIdCheck::IsVoice( aCallId ))

   966         {

   967         callData = iCallArrayOwner->GetCallObject( aCallId );

   968         if( callData )

   969             {

   970             errorCode = callData->GetCallInfo( aCallInfo );

   971             }

   972         else

   973             {

   974             __ASSERT_DEBUG( EFalse, Panic( EPEPanicIllegalCommand) );

   975             }

   976         }

   977         

   978     else if ( CallIdCheck::IsVideo( aCallId ) )

   979         {

   980         errorCode = iVideoCallHandling->GetCallInfo( aCallInfo, aCallId );

   981         }

   982         

   983     return errorCode;

   984     }

   985 

   986 // -----------------------------------------------------------------------------

   987 // CPECallHandling::GetCallState

   988 // Returns call state

   989 // -----------------------------------------------------------------------------

   990 //

   991 EXPORT_C TPEState CPECallHandling::GetCallState( 

   992         TInt aCallId )

   993     {

   994     TPEState callState( EPEStateUnknown );

   995     

   996     if ( CallIdCheck::IsConference( aCallId ) )

   997         {

   998         if( iConferenceCall )

   999             {

  1000             callState = iConferenceCall->GetCallState();

  1001             }

  1002         else

  1003             {

  1004             callState = EPEStateConferenceIdle;

  1005             }

  1006         }

  1007     else

  1008         {

  1009         CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

  1010         if( callData )

  1011             {

  1012             callState = callData->GetCallState();

  1013             }

  1014         else

  1015             {

  1016             callState = EPEStateIdle;

  1017             }

  1018         }

  1019 

  1020     TEFLOGSTRING2( KTAINT, "CALL CPECallHandling::GetCallState, callState: %d", callState );

  1021     return callState;

  1022     }

  1023 

  1024 // -----------------------------------------------------------------------------

  1025 // CPECallHandling::GetNumberOfCalls

  1026 // Returns number of non-idle calls

  1027 // -----------------------------------------------------------------------------

  1028 //

  1029 EXPORT_C TInt CPECallHandling::GetNumberOfCalls()

  1030     {

  1031     // Count ongoing calls

  1032     return iCallArrayOwner->ActiveCallCount();

  1033     }

  1034 

  1035 // -----------------------------------------------------------------------------

  1036 // CPECallHandling::GetCallDuration

  1037 // Returns voice call duration.

  1038 // -----------------------------------------------------------------------------

  1039 //

  1040 EXPORT_C TInt CPECallHandling::GetCallDuration( 

  1041     TTimeIntervalSeconds& aDuration,

  1042     TInt aCallId )

  1043     {

  1044     TInt errorCode( KErrNone );

  1045 

  1046     if ( CallIdCheck::IsVoice( aCallId ))

  1047         {

  1048         CPESingleCall* callData = iCallArrayOwner->GetCallObject( aCallId );

  1049         if( callData )

  1050             {

  1051             callData->GetCallDuration( aDuration );

  1052             }

  1053         else

  1054             {

  1055             __ASSERT_DEBUG( EFalse, Panic( EPEPanicIllegalCommand) );

  1056             }

  1057         }

  1058     else if ( CallIdCheck::IsVideo( aCallId ) )

  1059         {

  1060         iVideoCallHandling->GetCallDuration( aDuration, aCallId );

  1061         }

  1062     else if ( CallIdCheck::IsConference( aCallId ) )

  1063         {

  1064         if( iConferenceCall )

  1065             {

  1066             iConferenceCall->GetCallDuration( aDuration );

  1067             errorCode = KErrNone;

  1068             }

  1069         else

  1070             {

  1071             errorCode = ECCPErrorNotFound;

  1072             }

  1073         }

  1074     else

  1075         {

  1076         errorCode = ECCPErrorNotFound;

  1077         }

  1078     return errorCode;

  1079     }

  1080 

  1081 // -----------------------------------------------------------------------------

  1082 // CPECallHandling::RejectCall

  1083 // rejects the incoming call

  1084 // -----------------------------------------------------------------------------

  1085 //

  1086 EXPORT_C TInt CPECallHandling::RejectCall()

  1087     {

  1088     TEFLOGSTRING( KTAMESINT, "CALL CPECallHandling::RejectCall");

  1089     TInt callIndex;

  1090     TInt errorCode( ECCPErrorNotFound );

  1091     

  1092     CPESingleCall* callData = VoiceCallDataByState( EPEStateRinging, callIndex );

  1093     if( callIndex >= 0 )

  1094         {

  1095         callData->HangUp();

  1096         errorCode = KErrNone;

  1097         }

  1098     else

  1099         {

  1100         // Data call reject

  1101         errorCode = iVideoCallHandling->RejectCall();

  1102         }

  1103     return errorCode;

  1104     }

  1105 

  1106 // -----------------------------------------------------------------------------

  1107 // CPECallHandling::ReleaseAll

  1108 // Release ongoing calls

  1109 // -----------------------------------------------------------------------------

  1110 //

  1111 EXPORT_C TInt CPECallHandling::ReleaseAll()

  1112     {

  1113     TEFLOGSTRING( KTAMESINT, "CALL CPECallHandling::ReleaseAll");

  1114     CPESingleCall* callData;

  1115     TInt errorCode( ECCPErrorNotFound );

  1116     

  1117     // Normal Voice Calls

  1118     for ( TInt callId=0; callId < KPEMaximumNumberOfVoiceCalls; callId++ )

  1119         {

  1120         callData = iCallArrayOwner->GetCallObject( callId );

  1121         if( callData && 

  1122             callData->GetCallState() != EPEStateIdle &&

  1123             callData->GetCallState() != EPEStateRinging )

  1124             {

  1125             callData->HangUp();

  1126             errorCode = KErrNone;

  1127             }

  1128         }

  1129     

  1130     // Release ongoing data calls

  1131     errorCode ? errorCode = iVideoCallHandling->ReleaseAll() : iVideoCallHandling->ReleaseAll();

  1132       

  1133     TEFLOGSTRING2( KTAINT, "PE CPECallHandling::ReleaseAll, error id: %d", 

  1134         errorCode );