1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 

    18 //INCLUDE FILES

    19 #include "cmmfaxcalltsy.h"

    20 #include "cmmfaxlinetsy.h"

    21 #include "cmmphonetsy.h"

    22 #include "cmmtsyreqhandlestore.h"

    23 #include "cmmcalllist.h"

    24 #include "CMmCommonStaticUtility.h"

    25 #include "MmTsy_numberOfSlots.h"

    26 #include "cmmlinelist.h"

    27 #include "cmmmessagemanagerbase.h"

    28 #include <ctsy/pluginapi/cmmdatapackage.h>

    29 #include <ctsy/serviceapi/gsmerror.h>

    30 #include "CMmFaxExtInterface.h" 

    31 #include "cmmcallgsmwcdmaext.h"

    32 

    33 // ======== MEMBER FUNCTIONS ========

    34 

    35 CMmFaxCallTsy::CMmFaxCallTsy()

    36     {

    37     }

    38 

    39 CMmFaxCallTsy* CMmFaxCallTsy::NewL( 

    40     CMmPhoneTsy* aMmPhone, CMmFaxLineTsy* aMmLine,

    41     RMobilePhone::TMobileService aMode, 

    42     TDes& aName, 

    43     CMmMessageManagerBase* aMessageManager )

    44     {

    45 	TFLOGSTRING2("TSY: CMmFaxCallTsy::NewL. Call name: %S", &aName);

    46 

    47     CMmFaxCallTsy* mmCall = NULL;

    48 

    49     //check input parameters

    50     if ( aMmPhone != NULL && aMmLine != NULL &&

    51          aMode == RMobilePhone::EFaxService )

    52         {

    53         mmCall = new( ELeave ) CMmFaxCallTsy;

    54         CleanupClosePushL( *mmCall );

    55         mmCall->iMmPhone = aMmPhone;

    56         mmCall->iMmLine = aMmLine;

    57         mmCall->iCallName = aName;

    58         mmCall->iCallMode = aMode;

    59         mmCall->iMessageManager = aMessageManager;

    60         mmCall->ConstructL( aMode );

    61         CleanupStack::Pop();

    62         }

    63 

    64     return mmCall;

    65     }

    66 

    67 CMmFaxCallTsy::~CMmFaxCallTsy()

    68     {

    69     TFLOGSTRING3("TSY: CMmFaxCallTsy::~CMmFaxCallTsy. Call deleted \

    70         iCallId:%d iCallName:%S", iCallId, &iCallName);

    71 

    72     // If Dial fails, Symbian CSD agent will close the call immediately.

    73     // This means that TSY has not yet received call status indications, 

    74     // where call status changes to idle. Thus responses from modem are 

    75     // passed to call object. 

    76     // Here we need to assert that call object recovers dataport

    77     // if it is loaned.

    78     CCallBase::SetUnowned();

    79 

    80     // delete Internal Fax call extension object.

    81     if ( iMmFaxExt )

    82         {

    83         delete iMmFaxExt;

    84         }

    85     iMmFaxExt = NULL;

    86 

    87     // Check if dataport is loaned!

    88     if ( iLoanedCommPort.iPort.Compare( KNullDesC) != 0 )

    89         {

    90         //Create package

    91         CCallDataPackage package;

    92         //Set call id and call mode

    93         package.SetCallIdAndMode( iCallId, iCallMode );

    94         //Pack commport

    95         package.PackData( &iLoanedCommPort );

    96 

    97         //Send request to the Domestic OS layer.

    98         if( iMessageManager )

    99         	{

   100         	TRAP_IGNORE( 

   101             		iMessageManager->HandleRequestL(

   102                 		EEtelCallRecoverDataPort, &package );

   103             		   );

   104         	}

   105         iLoanedCommPort.iCsy.Zero();

   106         iLoanedCommPort.iPort.Zero();;

   107         }

   108         

   109     // If this is iLastIncomingFaxCall, set iLastIncomingFaxCall

   110     // of CMmFaxLineTsy to NULL

   111     if ( this == (reinterpret_cast<CMmFaxLineTsy*>(iMmLine))->iLastIncomingFaxCall )

   112     	{

   113         reinterpret_cast<CMmFaxLineTsy*>(iMmLine)->ResetLastIncomingCall();

   114     	}

   115     }

   116 

   117 

   118 // ---------------------------------------------------------------------------

   119 // CMmFaxCallTsy::InitExtensionModulesL

   120 // Initialises extension modules for CMmFaxCallTsy

   121 // (other items were commented in a header).

   122 // ---------------------------------------------------------------------------

   123 //

   124 void CMmFaxCallTsy::InitExtensionModulesL(

   125     RMobilePhone::TMobileService aMode )

   126     {

   127     CMmCallTsy::InitExtensionModulesL( aMode );

   128 

   129     // Create internal fax call object if this is fax call

   130     // TODO: what to do when this is faxmodem fax call??

   131     if ( aMode == RMobilePhone::EFaxService )

   132         {

   133         // Internal Fax call extension object creation.

   134         iMmFaxExt = CMmFaxExtInterface::NewL( this );

   135         }

   136     else

   137         {

   138         iMmFaxExt = NULL;

   139         }

   140     }

   141 

   142 // ---------------------------------------------------------------------------

   143 // CMmFaxCallTsy::InitInternalAttributes

   144 // Initialises miscellaneous internal attributes.

   145 // (other items were commented in a header).

   146 // ---------------------------------------------------------------------------

   147 //

   148 void CMmFaxCallTsy::InitInternalAttributes()

   149     {

   150     CMmCallTsy::InitInternalAttributes();

   151 

   152     iCallCaps.iFlags = RCall::KCapsFax | RCall::KCapsConnect;

   153 

   154     // Boolean that indicates if this call object is finished data call.

   155     // Required as Symbian CSD agent in situation where first data call

   156     // fails due wrong number and it then opens second data call, which

   157     // dials correct number. Call status notifications go to wrong call

   158     // object (the first one) and causes problems for clients.

   159     iIsFinishedDataCall = EFalse;

   160 

   161     //dataport params

   162     iLoanedCommPort.iCsy.Zero();

   163     iLoanedCommPort.iPort.Zero();;

   164     }

   165 

   166 // ---------------------------------------------------------------------------

   167 // CMmFaxCallTsy::OpenNewObjectByNameL

   168 // Creates new Fax object and returns a pointer to it.

   169 // (other items were commented in a header).

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

   171 //

   172 CTelObject* CMmFaxCallTsy::OpenNewObjectByNameL(    

   173     const TDesC& aName )

   174     {

   175     CTelObject* telObject = NULL;

   176 

   177     // iMmFaxExt is non null if fax calls are supported

   178     if ( iMmFaxExt )

   179         {

   180         telObject = iMmFaxExt->OpenNewObjectByNameL(aName);

   181         }

   182     else

   183         {

   184         //Not supported

   185         User::Leave( KErrNotSupported );

   186         }

   187 

   188     return telObject;

   189     }

   190 

   191 // ---------------------------------------------------------------------------

   192 // CMmFaxCallTsy::DoExtFuncL

   193 // DoExtFuncL is called by the Etel server when it has an "extended", i.e. 

   194 // non-core ETel request for the TSY. To process a request handle, request  

   195 // type and request data are passed to the TSY. 

   196 // (other items were commented in a header).

   197 // ---------------------------------------------------------------------------

   198 //

   199 TInt CMmFaxCallTsy::DoExtFuncL(

   200     const TTsyReqHandle aTsyReqHandle,

   201     const TInt aIpc,

   202     const TDataPackage& aPackage )

   203     {

   204     TFLOGSTRING3("TSY: CMmFaxCallTsy::DoExtFuncL. IPC:%d Handle:%d", aIpc, 

   205         aTsyReqHandle);

   206 

   207     TInt ret( KErrNone );

   208 

   209     TAny* dataPtr = aPackage.Ptr1();

   210 

   211     // The request data has to extracted from TDataPackage and the TAny* 

   212     // pointers have to be "cast" to the expected request data type

   213 

   214     // NOTE! Do not put any Cancel methods here.

   215     switch ( aIpc )

   216         {

   217       // Call Status

   218         // Get Call Status

   219         case EMobileCallGetMobileCallStatus:

   220             ret = GetMobileCallStatus( aTsyReqHandle,

   221                 reinterpret_cast<RMobileCall::TMobileCallStatus*>

   222                     ( dataPtr ) );

   223             break;

   224         // Notify Call Status Change

   225         case EMobileCallNotifyMobileCallStatusChange:

   226             ret = NotifyMobileCallStatusChange(

   227                 reinterpret_cast<RMobileCall::TMobileCallStatus*>

   228                     ( dataPtr ) );

   229             break;

   230         // Notify Call Event

   231         case EMobileCallNotifyCallEvent:

   232             ret = NotifyCallEvent(

   233                 reinterpret_cast<RMobileCall::TMobileCallEvent*>( dataPtr ) );

   234             break;

   235         // Call Control

   236         // Get Call Capabilities

   237         case EMobileCallGetMobileCallCaps: 

   238             ret = GetMobileCallCaps( aTsyReqHandle, aPackage.Des1n() );

   239             break;

   240 

   241         //Notify Call Capabilities Change

   242         case EMobileCallNotifyMobileCallCapsChange: 

   243             ret =  NotifyMobileCallCapsChange(aPackage.Des1n() );

   244             break;

   245 

   246       // Call Information

   247         // Get Mobile Call Information

   248         case EMobileCallGetMobileCallInfo:

   249             ret = GetMobileCallInfo( aTsyReqHandle, aPackage.Des1n() );

   250             break;

   251         // Notify Change of Remote Party Information

   252         case EMobileCallNotifyRemotePartyInfoChange:

   253             ret = NotifyRemotePartyInfoChange(

   254             reinterpret_cast<RMobileCall::TMobileCallRemotePartyInfoV1Pckg*>(

   255                     aPackage.Des1n()) );

   256             break;

   257         // Order to notify if privacy is confirmed

   258         case EMobileCallNotifyPrivacyConfirmation:

   259             ret = NotifyPrivacyConfirmation(

   260               reinterpret_cast<RMobilePhone::TMobilePhonePrivacy*>(

   261                 dataPtr ) );

   262             break;

   263         // Unsupported features

   264         case EMobileCallDialEmergencyCall:

   265         case EMobileCallHold:

   266         case EMobileCallResume:

   267         case EMobileCallSwap:

   268         case EMobileCallGoOneToOne:

   269         case EMobileCallGetMobileDataCallCaps: 

   270         case EMobileCallNotifyMobileDataCallCapsChange: 

   271         case EMobileCallGetMobileDataCallRLPRange:

   272         case EMobileCallSetDynamicHscsdParams:

   273         case EMobileCallGetCurrentHscsdInfo:

   274         case EMobileCallNotifyHscsdInfoChange:

   275         case EMobileCallSwitchAlternatingCall:

   276         case EMobileCallNotifyAlternatingCallSwitch:

   277         case EMobileCallSetPrivacy:

   278         case EMobileCallSetTrafficChannel:

   279         case EMobileCallNotifyTrafficChannelConfirmation:

   280         case EMobileCallGetUUSCaps:

   281         case EMobileCallNotifyUUSCapsChange:

   282         case EMobileCallActivateUUS:

   283         case EMobileCallSendUUI:

   284         case EMobileCallReceiveUUI:

   285         case EMobileCallHangupWithUUI:

   286         case EMobileCallAnswerWithUUI:

   287         case EMobileCallNotifyVoiceFallback:

   288         case EMobileCallDeflect:

   289         case EMobileCallActivateCCBS:

   290         case EMobileCallRejectCCBS:

   291         default:

   292             ret = KErrNotSupported;

   293             break;

   294         }

   295 

   296     return ret;

   297     }

   298 

   299 // ---------------------------------------------------------------------------

   300 // CMmFaxCallTsy::ReqModeL

   301 // ReqModeL is called from the ETel server's CTelObject::ReqAnalyserL in

   302 // order to check the type of request it has.

   303 // (other items were commented in a header).

   304 // ---------------------------------------------------------------------------

   305 //

   306 CTelObject::TReqMode CMmFaxCallTsy::ReqModeL(

   307     const TInt aIpc )

   308     {

   309     TFLOGSTRING2("TSY: CMmFaxCallTsy::ReqModeL. IPC:%d",aIpc); 

   310 

   311     CTelObject::TReqMode ret( 0 ); // default return value

   312     

   313     switch ( aIpc )

   314         {

   315         //No Flow Control

   316         //All disabled

   317         //TSYs wishing to implement their own buffering algorithm will place

   318         //all requests in this category.

   319         //This category will also be used by the RecoverDataPort request that

   320         //must be passed to the TSY to indicate that it may use the

   321         //communications port after a loan.

   322 

   323         //Get methods that do not use DOS and return immediately.

   324         //Flow control not required.

   325         case EEtelCallGetInfo:

   326         case EEtelCallGetStatus:

   327         case EEtelCallGetCaps:

   328         case EEtelCallGetBearerServiceInfo:

   329         case EEtelCallGetOwnershipStatus:

   330         case EEtelCallGetCallParams:

   331         case EEtelCallGetCallDuration:

   332         case EEtelCallGetFaxSettings:

   333         case EMobileCallGetMobileCallStatus:

   334         case EMobileCallGetMobileCallInfo:

   335         case EMobileCallGetMobileDataCallCaps:

   336         case EMobileCallGetMobileCallCaps:

   337         case EMobileCallGetCurrentHscsdInfo:

   338         case EMobileCallGetMobileDataCallRLPRange:

   339         case EMobileCallGetUUSCaps:

   340         case EMobileCallActivateUUS:

   341         case EMobileCallSendUUI:

   342         case EMobileCallReceiveUUI:

   343         case EMobileCallHangupWithUUI:

   344         case EMobileCallAnswerWithUUI:

   345         //Other methods that do not use DOS and return immediately.

   346         //Flow control not required.

   347         case EEtelCallAcquireOwnership:

   348         case EEtelCallTransferOwnership:

   349         case EEtelCallSetFaxSettings:

   350         //Methods that can propably take a long time and cannot therefore be

   351         //flow controlled. Solution: All these methods must check req handle

   352         //table before handling the request. In case that the request table

   353         //indicates that same method has been called and has not been

   354         //completed, the method should return KErrServerBusy.

   355         case EMobileCallTransfer:

   356         //This is also included here due to the fact that Emergency call

   357         //should never be blocked by flow control. KErrServerBusy returned

   358         //when already already dialing.

   359         case EMobileCallDialEmergencyCall:

   360         //HangUp cannot be flow controlled. Client should for example be able

   361         //to terminate a call while another call is e.g. in Dialling state.

   362         case EEtelCallHangUp:

   363         //Answer was mixed with Hangup.

   364         //Therefore this is also No flow control type.

   365         case EEtelCallAnswer:

   366         // dial is not flow controlled as compeltion may take a while and that

   367         // blocks for example PS data activation in 3G while dialing.

   368         case EEtelCallDial:

   369             break;

   370         //Flow Controlled Services

   371         //KReqModeFlowControlObeyed

   372         //Commands that change the state of the phone, e.g. clearing the

   373         //AoC counter; are commands that the TSY should only deal with

   374         //one at a time.

   375         

   376         //Voice call related methods that should be handled one at the time.

   377         case EEtelCallConnect:

   378         case EMobileCallHold:

   379         case EMobileCallResume:

   380         case EMobileCallSwap:

   381         case EMobileCallDeflect:

   382         case EMobileCallGoOneToOne:

   383         //Data call related methods that should be handled one at the time.

   384         case EEtelCallLoanDataPort:

   385         case EEtelCallRecoverDataPort:

   386         case EMobileCallSwitchAlternatingCall:

   387         case EMobileCallSetDynamicHscsdParams:

   388         case EMobileCallSetPrivacy:

   389         case EMobileCallSetTrafficChannel:

   390             ret = KReqModeFlowControlObeyed;

   391             break;

   392         //ReqModePostImmediately

   393         //Requests that notify a client about a change of state, where the

   394         //TSY needs to distinguish between different clients.

   395             //ret = KReqModeRePostImmediately;

   396 

   397         //KReqModeMultipleCompletionEnabled

   398         //(a) commands that may take some time, but which the TSY can handle

   399         //    more than one of concurrently, or

   400         //(b) notifications that the TSY does not wish to be re-posted

   401         //immediately, so the server does no buffering.

   402             //ret = KReqModeMultipleCompletionEnabled;

   403 

   404         //KReqModeMultipleCompletionEnabled | KReqModeFlowControlObeyed

   405         //A command that may take some time and which the TSY can only deal

   406         //with one at a time.

   407             //ret = KReqModeMultipleCompletionEnabled |

   408             //    KReqModeFlowControlObeyed;

   409             //break;

   410 

   411         //Notifications

   412         //KReqModeMultipleCompletionEnabled | ReqModePostImmediately

   413         //Requests that notify a client about a change of state.

   414         //Since these requests do not require the issuing of any modem

   415         //commands, they do not have to obey flow control.

   416         //The TSY never gets more than one of these outstanding per 

   417         // CTelObject.

   418         case EEtelCallNotifyHookChange:        

   419         case EEtelCallNotifyStatusChange:

   420         case EEtelCallNotifyDurationChange: 

   421         case EEtelCallCapsChangeNotification:

   422         case EMobileCallNotifyCallEvent:

   423         case EMobileCallNotifyMobileCallStatusChange:

   424         case EMobileCallNotifyRemotePartyInfoChange:

   425         case EMobileCallNotifyPrivacyConfirmation:

   426         case EMobileCallNotifyTrafficChannelConfirmation:

   427         case EMobileCallNotifyHscsdInfoChange:

   428         case EMobileCallNotifyMobileDataCallCapsChange:

   429         case EMobileCallNotifyAlternatingCallSwitch:

   430         case EMobileCallNotifyMobileCallCapsChange:

   431         case EMobileCallNotifyVoiceFallback:

   432         case EMobileCallNotifyUUSCapsChange:

   433             ret = KReqModeMultipleCompletionEnabled | 

   434                                                     KReqModeRePostImmediately;

   435             break;

   436         //Cancel Requests

   437         //It is not necessary to include the Cancel methods in ReqModeL at all

   438         //The ETel server never calls ReqModeL with a Cancel IPC.

   439 

   440         //Other variations of return values are unusable

   441 

   442         //Default: Call CCallBase's ReqModeL.

   443         default:

   444             //Direct the request to the CCallBase

   445             ret = CCallBase::ReqModeL( aIpc );

   446             break;

   447         }

   448 

   449     return ret;

   450     }

   451 

   452 // ---------------------------------------------------------------------------

   453 // CMmFaxCallTsy::NumberOfSlotsL

   454 // NumberOfSlotsL is called by the server when it is registering a new 

   455 // NOTIFICATION. It enables the TSY to tell the server how many buffer slots

   456 // to allocate for "repost immediately" notifications that may trigger before

   457 // clients collect them.

   458 // (other items were commented in a header).

   459 // ---------------------------------------------------------------------------

   460 //

   461 TInt CMmFaxCallTsy::NumberOfSlotsL(

   462     const TInt aIpc )

   463     {

   464     //There is a buffer in the ETel server for each type of NOTIFICATION and

   465     //the size of the buffer is determined by the TSY. When the ETel server

   466     //discovers that a request is "repost immediately" it will ask the TSY

   467     //how big a buffer it wants by calling CTelObject::NumberOfSlotsL( ).

   468     //

   469     //It is up to the TSY developer's judgement how many buffer slots this

   470     //method returns for each notification. If there is a danger that

   471     //a particular notification could trigger frequently and in rapid

   472     //succession (e.g. call group change notification) then at least 10 or

   473     //20 slots may be required. For a notification that triggers rarely,

   474     //perhaps 1 or 2 slots is enough.

   475     //

   476     //So if the ETel server has stored a few occurrences of a particular

   477     //notification, when a client subsequently calls that notification request

   478     //the ETel server will complete the client's request with the saved data. 

   479 

   480     TInt numberOfSlots( 1 );

   481 

   482     switch ( aIpc ) 

   483         {

   484         case EEtelCallNotifyHookChange:

   485             numberOfSlots = KMmCallHookChangeSlots;

   486             break;

   487         case EEtelCallNotifyStatusChange:

   488             numberOfSlots = KMmCallStatusChangeSlots;

   489             break;

   490         case EEtelCallNotifyDurationChange: 

   491             numberOfSlots = KMmCallDurationChangeSlots;

   492             break;

   493         case EEtelCallCapsChangeNotification:

   494             numberOfSlots = KMmCallCapsChangeSlots;

   495             break;

   496         case EMobileCallNotifyCallEvent:

   497             numberOfSlots = KMmCallCallEventSlots;

   498             break;

   499         case EMobileCallNotifyMobileCallStatusChange:

   500             numberOfSlots = KMmCallMobileCallStatusChangeSlots;

   501             break;

   502         case EMobileCallNotifyRemotePartyInfoChange:

   503             numberOfSlots = KMmCallRemotePartyInfoChangeSlots;

   504             break;

   505         case EMobileCallNotifyPrivacyConfirmation:

   506             numberOfSlots = KMmCallPrivacyConfirmationSlots;

   507             break;

   508         case EMobileCallNotifyTrafficChannelConfirmation:

   509             numberOfSlots = KMmCallTrafficChannelConfirmationSlots;

   510             break;

   511         case EMobileCallNotifyHscsdInfoChange:

   512             numberOfSlots = KMmCallHscsdInfoChangeSlots;

   513             break;

   514         case EMobileCallNotifyMobileDataCallCapsChange:

   515             numberOfSlots = KMmCallMobileDataCallCapsChangeSlots;

   516             break;

   517         case EMobileCallNotifyAlternatingCallSwitch:

   518             numberOfSlots = KMmCallAlternatingCallSwitchSlots;

   519             break;

   520         case EMobileCallNotifyMobileCallCapsChange:

   521             numberOfSlots = KMmCallMobileCallCapsChangeSlots;

   522             break;

   523         case EMobileCallNotifyVoiceFallback:

   524             numberOfSlots = KMmCallVoiceFallbackSlots;

   525             break;

   526         case EMobileCallNotifyUUSCapsChange:

   527             numberOfSlots = KMmCallUUSCapsChangeSlots;

   528             break;

   529         default:

   530             // Unknown or invalid Call IPC

   531             User::Leave( KErrNotSupported );

   532             break;

   533         }

   534 

   535     return numberOfSlots;

   536     }

   537 

   538 // ---------------------------------------------------------------------------

   539 // CMmFaxCallTsy::CancelService

   540 // CancelService is called by the ETel server when it is "cleaning-up" any 

   541 // still outstanding asynchronous requests before closing a client's 

   542 // sub-session. This will happen if a client closes its R-class handle without 

   543 // cancelling outstanding asynchronous requests. Only Mobile API requests are 

   544 // handled here.

   545 // (other items were commented in a header).

   546 // ---------------------------------------------------------------------------

   547 //

   548 TInt CMmFaxCallTsy::CancelService(

   549     const TInt aIpc,

   550     const TTsyReqHandle aTsyReqHandle )

   551     {

   552     TFLOGSTRING3("TSY: CMmFaxCallTsy::CancelService. IPC: %d, Req handle: %d",

   553         aIpc, aTsyReqHandle); 

   554 

   555     TInt ret( KErrNone );

   556 

   557     //When the clients close their sub-sessions (eg. by calling RPhone::Close)

   558     //they may not have cancelled all their outstanding asynchronous requests

   559     //before closing.  It is up to the ETel server to clean up in this

   560     //situation, so the server will find the list of outstanding requests

   561     //related to that sub-session object and pass these outstanding IPC req.

   562     //numbers, one at a time, to the CancelService function in the TSY.

   563 

   564     switch ( aIpc )

   565         {

   566         //TSY has started a request and it is not possible to then

   567         //cancel this request. The best thing for the TSY to do in this case

   568         //is to proceed as though the Cancel never happened. The server's call

   569         //to the TSY cancel function will return synchronously. The TSY then

   570         //continues to wait for the original acknowledgement and when it

   571         //receives it, the TSY will complete the original request.

   572         case EMobileCallHold:

   573         case EMobileCallResume:

   574         case EMobileCallSwap:

   575         case EMobileCallGoOneToOne:

   576         case EMobileCallDeflect:

   577         case EMobileCallTransfer:

   578         case EMobileCallNotifyTrafficChannelConfirmation:

   579             break;

   580         //Cancel methods that are not supported

   581         case EMobileCallDialEmergencyCall:

   582 

   583         case EMobileCallSetDynamicHscsdParams:

   584         case EMobileCallNotifyMobileDataCallCapsChange:

   585         case EMobileCallNotifyHscsdInfoChange:

   586 

   587         case EMobileCallSwitchAlternatingCall:

   588         case EMobileCallNotifyAlternatingCallSwitch:

   589         case EMobileCallGetMobileDataCallRLPRange:

   590         case EMobileCallNotifyVoiceFallback:

   591         case EMobileCallNotifyUUSCapsChange:

   592         case EMobileCallActivateUUS:

   593         case EMobileCallSendUUI:

   594         case EMobileCallReceiveUUI:

   595         case EMobileCallHangupWithUUI:

   596         case EMobileCallAnswerWithUUI:

   597             ret = KErrNotSupported;

   598             break;

   599         //Notification Cancels, no special requirements.

   600         case EMobileCallNotifyMobileCallCapsChange:

   601             ret = NotifyMobileCallCapsChangeCancel( aTsyReqHandle );

   602             break;

   603         case EMobileCallNotifyMobileCallStatusChange:

   604             ret = NotifyMobileCallStatusChangeCancel( aTsyReqHandle );

   605             break;

   606         case EMobileCallNotifyCallEvent:

   607             ret = NotifyCallEventCancel( aTsyReqHandle );

   608             break;

   609         case EMobileCallNotifyRemotePartyInfoChange:

   610             ret = NotifyRemotePartyInfoChangeCancel( aTsyReqHandle );

   611             break;

   612         case EMobileCallNotifyPrivacyConfirmation:

   613             ret = NotifyPrivacyConfirmationCancel( aTsyReqHandle );

   614             break;

   615         //Default case

   616         default:

   617             //call CCallBase

   618             ret = CCallBase::CancelService( aIpc, aTsyReqHandle );

   619             break;

   620         }

   621 

   622     return ret;

   623     }

   624 

   625 // ---------------------------------------------------------------------------

   626 // CMmFaxCallTsy::CompleteNotifyStatusChange

   627 // Complete notification when status changes. If the new status requires,

   628 // this method will ask call protocol extension to update it's status and

   629 // capabilities and line owning this call to update it's status.

   630 // (other items were commented in a header).

   631 // ---------------------------------------------------------------------------

   632 //

   633 void CMmFaxCallTsy::CompleteNotifyStatusChange(

   634     TInt aResult,

   635     CMmDataPackage* aDataPackage )

   636     {

   637     if ( iGhostCall ) 

   638         {

   639         HandleGhostCallStatusChange( aResult, aDataPackage );

   640         }

   641     else

   642         {

   643         TInt callIndex( 0 ); 

   644         TInt extendedError( 

   645             CMmCommonStaticUtility::ExtendedErrorCode( aResult) );

   646         TInt ret( KErrNone );

   647         TBool timerStarted( EFalse );

   648         TBool statusChanged ( EFalse );

   649         TBool mobileStatusChanged ( EFalse );

   650         CMmFaxCallTsy* mmCall = NULL; 

   651         RMobileCall::TMobileCallStatus callStatus( RMobileCall::EStatusIdle );

   652         CCallDataPackage* callDataPackage = 

   653             reinterpret_cast<CCallDataPackage*>(aDataPackage);

   654 

   655         callDataPackage->UnPackData( callStatus );

   656 

   657         TFLOGSTRING2("TSY: CMmFaxCallTsy::CompleteNotifyStatusChange. aResult:%d",

   658             aResult ); 

   659         TFLOGSTRING3("TSY: CMmFaxCallTsy::CompleteNotifyStatusChange. \

   660             Call status:%d Call name:%S", callStatus, &iCallName); 

   661 

   662         switch( callStatus )

   663             {

   664             case RMobileCall::EStatusIdle:

   665                 //reset caps. 

   666                 iCallCaps.iFlags &= ~(

   667                     RCall::KCapsHangUp | RCall::KCapsAnswer );

   668                 iCallCaps.iFlags |= RCall::KCapsDial;

   669 

   670                 //stop the call duration timer

   671                 timerStarted = iCallTimer->Stop();

   672                 //Check air time timer only if call was in active state

   673                 //(call timer was started)

   674                 if ( timerStarted )

   675                     {

   676                     iMmPhone->AirTimeTimerCheckStop();

   677                     UpdateLifeTimer();                    

   678                     }

   679 

   680                 iCallStatus = RCall::EStatusIdle;

   681                 iMobileCallStatus = RMobileCall::EStatusIdle;

   682 

   683                 SetUnowned();

   684 

   685                 ClearCallStatus();

   686                 statusChanged = ETrue;

   687 

   688                 if ( KErrNone != aResult )

   689                     {

   690                     if ( KErrGsmReleaseByUser == aResult || 

   691                         KErrGsmBusyUserRequest == aResult )

   692                         {

   693                         // aResult must be KErrNone to indicate the client

   694                         // that HangUp has successfully completed

   695                         CompleteHangUp( KErrNone );

   696                         if ( this != iMmPhone->WaitingCallForData() )

   697                             {

   698                             CompleteAnswerIncomingCall( 

   699                                 KErrGsmBusyUserRequest );

   700                             }

   701                         }

   702                     else

   703                         {

   704                         //set last exit code

   705                         iLastExitCode = aResult;

   706                         CompleteHangUp( aResult );

   707                         if ( this != iMmPhone->WaitingCallForData() )

   708                             {

   709                             CompleteAnswerIncomingCall( aResult );

   710                             }

   711                         }

   712                     CompleteDial( aResult );

   713                     }

   714                 // Try to complete Dial and HangUp; If completes happens from 

   715                 // here, something has gone wrong. Done to prevent TSY from 

   716                 // hanging.

   717                 else

   718                     {

   719                     iLastExitCode = KErrGeneral;

   720                     TInt errorValue = CMmCommonStaticUtility::EpocErrorCode( 

   721                         KErrNotReady, KErrNotFound );

   722                     CompleteDial( errorValue );

   723                     CompleteHangUp( errorValue );

   724                     if ( this != iMmPhone->WaitingCallForData() )

   725                         {

   726                         CompleteAnswerIncomingCall( errorValue );

   727                         }

   728                     }

   729                 //save last id. Required by Conference call implementation

   730                 SetPreviousCallId( iCallId );

   731                 //reset call id

   732                 iCallId = -1;

   733 

   734                 //Check if call capability KCapsHangup still exists

   735                 //If it does, remove it and return the KCapsDial capability.

   736                 //If call mode is data, then return also KCapsConnect 

   737                 //capability

   738                 if ( RCall::KCapsHangUp == 

   739                     ( iCallCaps.iFlags & RCall::KCapsHangUp ) )

   740                     {

   741                     // Remove KCapsHangUp if it exists

   742                     iCallCaps.iFlags &= ~( RCall::KCapsHangUp );

   743                     // return the KCapsDial capability.

   744                     iCallCaps.iFlags |= RCall::KCapsDial;

   745 

   746                     CompleteNotifyCapsChange();

   747                     }

   748 

   749                 //Call Transfer handling

   750                 if ( ServiceRequested( EMultimodeCallTransfer ) )

   751                     {

   752                     //Complete Transfer 

   753                     CompleteTransfer( KErrNone );

   754                     }

   755                 break;

   756                 //End of case KCallStatusIdle

   757             case RMobileCall::EStatusDialling:

   758                 #ifdef REQHANDLE_TIMER

   759                 iTsyReqHandleStore->StopTimeout( EMultimodeCallDial );

   760                 #endif

   761                 iCallStatus = RCall::EStatusDialling;

   762                 iMobileCallStatus = RMobileCall::EStatusDialling;

   763                 statusChanged = ETrue;

   764                 if ( iDialCancelFlag != CMmCallTsy::EDialCancelNotCalled )

   765                     {

   766                     TTsyReqHandle dialCancelHandle = iTsyReqHandleStore->

   767                         GetTsyReqHandle( EMultimodeCallDial );

   768 

   769                     if ( 0 < dialCancelHandle )

   770                         {

   771                         HangUp( dialCancelHandle );

   772                         } 

   773                     else

   774                         {

   775                         iDialCancelFlag = CMmCallTsy::EDialCancelNotCalled;

   776                         }

   777                     }

   778                 break;

   779             case RMobileCall::EStatusConnecting:

   780                 iCallStatus = RCall::EStatusConnecting;

   781                 iMobileCallStatus = RMobileCall::EStatusConnecting;

   782                 statusChanged = ETrue;

   783                 break;

   784             case RMobileCall::EStatusRinging:

   785                 // If mode is fax call, there is a chance that call mode is 

   786                 //already ringing

   787                 if (RCall::EStatusRinging != iCallStatus ||

   788                     RMobileCall::EStatusRinging != iMobileCallStatus)

   789                     {

   790                     iCallStatus = RCall::EStatusRinging;

   791                     iMobileCallStatus = RMobileCall::EStatusRinging;

   792                     statusChanged = ETrue;

   793                     }

   794                 break;

   795             case RMobileCall::EStatusAnswering:

   796                 iCallStatus = RCall::EStatusAnswering;

   797                 iMobileCallStatus = RMobileCall::EStatusAnswering;

   798                 statusChanged = ETrue;

   799 

   800                 CompleteAnswerIncomingCall( aResult );

   801                 break;

   802             case RMobileCall::EStatusConnected:

   803                 //check previous status. If status is answering

   804                 if ( RCall::EStatusAnswering == iCallStatus )

   805                     {

   806                     //Start call duration monitoring

   807                     iCallTimer->Start(); 

   808                     //Check if start the air time duration monitoring

   809                     iMmPhone->AirTimeTimerCheckStart();

   810                     }

   811                 //if it was connecting and dial cancel has not been activated

   812                 else if ( ( iCallStatus == RCall::EStatusConnecting ||

   813                     iCallStatus == RCall::EStatusDialling ) &&

   814                     CMmCallTsy::EDialCancelNotCalled == iDialCancelFlag )

   815                     {

   816                     //Start call duration monitoring

   817                     iCallTimer->Start(); 

   818                     //start air time duration monitoring

   819                     iMmPhone->AirTimeTimerCheckStart();

   820                     }

   821 

   822                 //Don't update status if it has not changed.

   823                 if ( RCall::EStatusConnected != iCallStatus ||

   824                     RMobileCall::EStatusConnected != iMobileCallStatus )

   825                     {

   826                     iCallStatus = RCall::EStatusConnected;

   827                     iMobileCallStatus = RMobileCall::EStatusConnected;

   828                     statusChanged = ETrue;

   829                     }

   830                 break;

   831             case RMobileCall::EStatusDisconnecting:

   832                 // When call is released, this call object becomes "used".

   833                 // Thus set iIsFinishedDataCall to ETrue. 

   834                 iIsFinishedDataCall = ETrue;

   835                 //Core status

   836                 iCallStatus = RCall::EStatusHangingUp; 

   837                 statusChanged = ETrue;

   838                 // Mobile status

   839                 iMobileCallStatus = RMobileCall::EStatusDisconnecting;

   840                 mobileStatusChanged = ETrue;

   841 

   842                 if ( iCallDirection == RMobileCall::EMobileTerminated )

   843                     {

   844                     //CompleteDial in case remote user is busy

   845                     CompleteDial( aResult );

   846 

   847                     //Set last exit code

   848                     if ( KErrGsmReleaseByUser == aResult ||

   849                         KErrGsmBusyUserRequest == aResult ||

   850                         KErrGsmCCNormalUnspecified == extendedError ||

   851                         KErrNone == aResult )

   852                         {

   853                         iLastExitCode = KErrNone;

   854                         }

   855                     else

   856                         {

   857                         //set last exit code

   858                         iLastExitCode = aResult;

   859                         }

   860                     }

   861                 break;

   862             case RMobileCall::EStatusDisconnectingWithInband:

   863                 // When call is released, this call object becomes "used".

   864                 // Thus set iIsFinishedDataCall to ETrue. 

   865                 iIsFinishedDataCall = ETrue;

   866                 //Core status

   867                 iCallStatus = RCall::EStatusHangingUp; 

   868                 statusChanged = ETrue;

   869                 // Mobile status

   870                 iMobileCallStatus =

   871                     RMobileCall::EStatusDisconnectingWithInband;

   872                 mobileStatusChanged = ETrue;

   873                 //CompleteDial in case remote user is busy

   874                 CompleteDial( aResult );

   875 

   876                 //Set last exit code

   877                 if ( KErrGsmReleaseByUser == aResult ||

   878                     KErrGsmBusyUserRequest == aResult ||

   879                     KErrGsmCCNormalUnspecified == extendedError ||

   880                     KErrNone == aResult )

   881                     {

   882                     iLastExitCode = KErrNone;

   883                     }

   884                 else

   885                     {

   886                     //set last exit code

   887                     iLastExitCode = aResult;

   888                     }

   889                 break;

   890             case RMobileCall::EStatusHold:

   891             case RMobileCall::EStatusUnknown:

   892             case RMobileCall::EStatusReconnectPending:

   893             case RMobileCall::EStatusWaitingAlternatingCallSwitch:

   894             case RMobileCall::EStatusTransferring:

   895             case RMobileCall::EStatusTransferAlerting:

   896             default:

   897                 //nothing to do

   898                 break;

   899             }

   900 

   901         //reset req handle. Returns the deleted req handle

   902         TTsyReqHandle reqHandle = iTsyReqHandleStore->

   903             GetTsyReqHandle( EMultimodeCallNotifyStatusChange );

   904 

   905         if ( ( EMultimodeCallReqHandleUnknown != reqHandle ) 

   906             && statusChanged )

   907             {

   908             *iRetStatus = iCallStatus;

   909             //reset req handle. 

   910             iTsyReqHandleStore->ResetTsyReqHandle(

   911                 EMultimodeCallNotifyStatusChange );

   912 

   913             ReqCompleted( reqHandle, ret );

   914             }

   915 

   916         //reset req handle. Returns the deleted req handle

   917         reqHandle = iTsyReqHandleStore->GetTsyReqHandle(

   918             EMultimodeCallNotifyMobileCallStatusChange );

   919 

   920         if ( ( EMultimodeCallReqHandleUnknown != reqHandle ) &&

   921             ( statusChanged || mobileStatusChanged ) )

   922             {

   923             *iRetMobileCallStatus = iMobileCallStatus;

   924             //reset req handle. 

   925             iTsyReqHandleStore->ResetTsyReqHandle(

   926                 EMultimodeCallNotifyMobileCallStatusChange );

   927             ReqCompleted( reqHandle, ret );

   928             }

   929 

   930         //Update also line's status

   931         if ( statusChanged || mobileStatusChanged )

   932             {

   933             iMmLine->CompleteNotifyStatusChange();

   934             }

   935 

   936         //Inform extension dll about the current status. Enables dynamic

   937         //capability updates. Must be done before Notifying caps change

   938         if ( KErrNone == iMmCallExtInterface-> 

   939             CompleteNotifyStatusChange( iMobileCallStatus ) )

   940             { 

   941             CompleteNotifyMobileCallCapsChange( KErrNone );

   942             }

   943 

   944         mmCall = reinterpret_cast<CMmFaxCallTsy*>(

   945             iMmPhone->CallList()->GetMmCallByIndex( callIndex ) );

   946         while ( mmCall ) 

   947             { 

   948             if ( RMobileCall::EStatusIdle != mmCall->MobileCallStatus() &&

   949                  this != mmCall )

   950                 { 

   951                 if ( KErrNone ==

   952                     mmCall->ActiveCallExtension()-> 

   953                     CompleteNotifyStatusChange( mmCall->MobileCallStatus() ) )

   954                     { 

   955                     mmCall->CompleteNotifyMobileCallCapsChange( KErrNone );

   956                     }

   957                 } 

   958             callIndex++;

   959             mmCall = reinterpret_cast<CMmFaxCallTsy*>(

   960                 iMmPhone->CallList()->GetMmCallByIndex( callIndex ) );

   961             }

   962         }

   963     }

   964 

   965 // ---------------------------------------------------------------------------

   966 // CMmFaxCallTsy::Dial

   967 // This CORE API method dials to the given number.

   968 // (other items were commented in a header).

   969 // ---------------------------------------------------------------------------

   970 //

   971 TInt CMmFaxCallTsy::Dial(

   972     const TTsyReqHandle aTsyReqHandle,

   973     const TDesC8* aCallParams,

   974     TDesC* aTelNumber )

   975     {

   976     TFLOGSTRING3("TSY: CMmFaxCallTsy::Dial. Req handle: %d, Call name: %S", 

   977         aTsyReqHandle, &iCallName);

   978 

   979 	CMmCallList* callList = iMmPhone->CallList();

   980 	TBool dialFlag( EFalse );

   981 	

   982 	for(TInt i=0; i< callList->GetNumberOfObjects();i++)

   983 		{		

   984 		CMmCallTsy* call = callList->GetMmCallByIndex( i );

   985 		if( call->GetDialFlag() )

   986 			{

   987 			dialFlag = ETrue;

   988 			i= callList->GetNumberOfObjects();

   989 			}

   990 		}

   991 		

   992 	if(!dialFlag )

   993 	{

   994 	SetDialFlag( ETrue );

   995     TTsyReqHandle dialHandle = iTsyReqHandleStore->

   996         GetTsyReqHandle( EMultimodeCallDial );

   997     

   998     //reset exit code

   999     iLastExitCode = KErrNone;

  1000 

  1001     //reset finished data call flag

  1002     iIsFinishedDataCall = EFalse;

  1003 

  1004     if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() )

  1005         {

  1006         TFLOGSTRING("TSY: Offline mode ON, Dial request is not allowed" );

  1007         TInt ret = CMmCommonStaticUtility::EpocErrorCode(

  1008             KErrGeneral, KErrGsmOfflineOpNotAllowed );

  1009 

  1010         //Complete the request with appropiate error

  1011         ReqCompleted ( aTsyReqHandle, ret ); 

  1012         }

  1013 

  1014     //check that status is Idle

  1015     else if ( RMobileCall::EStatusIdle != iMobileCallStatus )

  1016         {

  1017         //The request cannot be forwarded since this call object

  1018         //is still in use.

  1019         //Complete request with status value informing the client

  1020         //about the situation.

  1021         TFLOGSTRING("TSY: CMmFaxCallTsy::Dial - KErrNotReady");

  1022         ReqCompleted( aTsyReqHandle, KErrNotReady );

  1023         }

  1024     else if ( 0 < dialHandle )

  1025         {

  1026         //The request is already in processing because of previous request

  1027         //Complete request with status value informing the client about 

  1028         //the situation.

  1029         TFLOGSTRING("TSY: CMmFaxCallTsy::Dial - KErrServerBusy");

  1030         ReqCompleted( aTsyReqHandle, KErrServerBusy );

  1031         }

  1032     else

  1033         {

  1034         TInt ret( KErrNone );

  1035 

  1036         RMobileCall::TMobileCallParamsV1Pckg* paramsPckgV1 = 

  1037             reinterpret_cast<RMobileCall::TMobileCallParamsV1Pckg*>(

  1038                 const_cast<TDesC8*>( aCallParams ) );

  1039         RMobileCall::TMobileCallParamsV1& paramsV1 = ( *paramsPckgV1 )();

  1040 

  1041         //save call params

  1042         iCallParams.iSpeakerControl = paramsV1.iSpeakerControl;

  1043         iCallParams.iSpeakerVolume = paramsV1.iSpeakerVolume;

  1044         iCallParams.iInterval = paramsV1.iInterval;

  1045         iCallParams.iWaitForDialTone = paramsV1.iWaitForDialTone;

  1046 

  1047         //set call direction

  1048         iCallDirection = RMobileCall::EMobileOriginated;

  1049 

  1050         // if fax extension is loaded do a fax call, otherwise return not supported

  1051         if (iMmFaxExt)

  1052             {

  1053             // Check if there already is an active or connecting call

  1054             TInt numberOfObjects = iMmPhone->CallList()->

  1055                 GetNumberOfObjects();

  1056             for ( TInt i = 0; i < numberOfObjects; i++ )

  1057                 {

  1058                 CMmCallTsy* mmCall = iMmPhone->CallList()->

  1059                     GetMmCallByIndex( i );

  1060                 if ( !( RMobileCall::EStatusUnknown == 

  1061                             mmCall->MobileCallStatus() ||

  1062                         RMobileCall::EStatusIdle == 

  1063                             mmCall->MobileCallStatus() ||

  1064                         RMobileCall::EStatusDisconnecting == 

  1065                             mmCall->MobileCallStatus() ||

  1066                         RMobileCall::EStatusDisconnectingWithInband == 

  1067                             mmCall->MobileCallStatus() ) )

  1068                     {

  1069                     ret = KErrEtelCallAlreadyActive;

  1070                     break;

  1071                     }

  1072                 }

  1073 

  1074             if ( KErrNone == ret )

  1075                 {

  1076                 ret = iMmFaxExt->Dial(aTsyReqHandle, aTelNumber);

  1077                 }

  1078             }

  1079         else

  1080             {

  1081             ret = KErrNotSupported;

  1082             }

  1083 

  1084         if ( KErrNone != ret )

  1085             {

  1086             ReqCompleted( aTsyReqHandle, ret );

  1087             ClearCallStatus();

  1088             }

  1089         else

  1090             {

  1091 #ifdef REQHANDLE_TIMER

  1092             //set timer for the request

  1093             SetTypeOfResponse( EMultimodeCallDial, aTsyReqHandle );

  1094 #else

  1095             //set timer

  1096             iTsyReqHandleStore->SetTsyReqHandle(

  1097                 EMultimodeCallDial, aTsyReqHandle );

  1098 #endif

  1099             }

  1100         }

  1101 

  1102     return KErrNone;

  1103     }

  1104 	else

  1105 		return KErrServerBusy;

  1106     }

  1107 

  1108 	

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

  1110 // CMmFaxCallTsy::DialCancel

  1111 // This CORE API method cancels an outstanding dial request.Calls HangUp 

  1112 // method to do this and set a flag so that we can know that DialCancel 

  1113 // handling is going on.

  1114 // (other items were commented in a header).

  1115 // ---------------------------------------------------------------------------

  1116 //

  1117 TInt CMmFaxCallTsy::DialCancel(

  1118     const TTsyReqHandle aTsyReqHandle )

  1119     {

  1120     TFLOGSTRING3("TSY: CMmFaxCallTsy::DialCancel. Req handle: %d, Call name: %S", 

  1121         aTsyReqHandle, &iCallName);

  1122 

  1123     TInt ret( KErrGeneral );

  1124 

  1125     if (iMmFaxExt)

  1126         {

  1127         iMmFaxExt->DialCancel();

  1128         // ingnore dialcancel for internal fax call

  1129         return KErrNone;

  1130         }

  1131 

  1132     ret = CMmCallTsy::DialCancel( aTsyReqHandle );

  1133 

  1134     return ret;