1 /*

     2 * Copyright (c) 2007-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:  Contains the implementation of class CSPEtelCallRequester

    15 *

    16 */

    17 

    18 #include "cspetelcallrequester.h"

    19 

    20 #include <exterror.h>

    21 #include <gsmerror.h>

    22 #include <etelmmerr.h>

    23 #include <etelsat.h>

    24 

    25 #include "mcspcallerrorobserver.h"

    26 #include "csplogger.h"

    27 

    28 

    29 // ---------------------------------------------------------------------------

    30 // Constructs the requester via two phased constructing.

    31 // ---------------------------------------------------------------------------

    32 //

    33 CSPEtelCallRequester* CSPEtelCallRequester::NewL(

    34             MCSPCallErrorObserver& aObserver,

    35             RMobileCall& aCall ) 

    36     {

    37     CSPLOGSTRING(CSPOBJECT, "CSPEtelCallRequester::NewL()" );

    38     CSPEtelCallRequester* self = new ( ELeave ) CSPEtelCallRequester( 

    39                                         aObserver, aCall );

    40     return self;

    41     }

    42     

    43 // ---------------------------------------------------------------------------

    44 // Destructor of the object.

    45 // ---------------------------------------------------------------------------

    46 //

    47 CSPEtelCallRequester::~CSPEtelCallRequester( )

    48     {

    49     CSPLOGSTRING(CSPOBJECT, "CSPEtelCallRequester::~CSPEtelCallRequester()" );

    50     CSPLOGSTRING2(CSPINT, "CSPEtelCallRequester:: type: %d", iRequestType );

    51     Cancel();

    52     }

    53 

    54 // ---------------------------------------------------------------------------

    55 // CSPEtelCallRequester::MakeDialRequest

    56 // ---------------------------------------------------------------------------

    57 //

    58 TInt CSPEtelCallRequester::MakeDialRequest( 

    59             const TDesC8& aCallParams, 

    60             TDesC& aRecipient )

    61     {

    62     CSPLOGSTRING(CSPINT, "CSPEtelCallRequester::MakeDialRequest" );

    63     iRequestType = ERequestTypeDial;

    64 

    65     if ( !IsActive() )

    66         {

    67         iCall.Dial( iStatus, aCallParams, aRecipient );

    68         SetActive();

    69         }

    70     else

    71         {

    72         return KErrInUse;

    73         }

    74     

    75     return KErrNone;

    76     }

    77     

    78 // ---------------------------------------------------------------------------

    79 // CSPEtelCallRequester::MakeDialNoFdnCheckRequest

    80 // ---------------------------------------------------------------------------

    81 //

    82 TInt CSPEtelCallRequester::MakeDialNoFdnCheckRequest( 

    83             const TDesC8& aCallParams, 

    84             TDesC& aRecipient )

    85     {

    86     CSPLOGSTRING(CSPINT, "CSPEtelCallRequester::MakeDialNoFdnCheckRequest" );

    87     iRequestType = ERequestTypeDial;

    88 

    89     if ( !IsActive() )

    90         {

    91         iCall.DialNoFdnCheck( iStatus, aCallParams, aRecipient );

    92         SetActive();

    93         }

    94     else

    95         {

    96         return KErrInUse;

    97         }

    98     

    99     return KErrNone;

   100     }

   101 

   102 // ---------------------------------------------------------------------------

   103 // CSPEtelCallRequester::MakeAnswerRequest

   104 // ---------------------------------------------------------------------------

   105 //

   106 TInt CSPEtelCallRequester::MakeAnswerRequest(

   107             const TDesC8& aCallParams )

   108     {

   109     CSPLOGSTRING(CSPINT, "CSPEtelCallRequester::MakeAnswerRequest" );

   110     if ( !IsActive() )

   111         {

   112         iRequestType = ERequestTypeAnswer;

   113         iCall.AnswerIncomingCall( iStatus, aCallParams );

   114         SetActive();

   115         }

   116     else

   117         {

   118         return KErrInUse;

   119         }

   120     

   121     return KErrNone;

   122     }

   123 

   124 // ---------------------------------------------------------------------------

   125 // CSPEtelCallRequester::MakeDialEmergencyRequest

   126 // ---------------------------------------------------------------------------

   127 //

   128 TInt CSPEtelCallRequester::MakeDialEmergencyRequest( 

   129                             const RMobileENStore::TEmergencyNumber& aRecipient )

   130     {

   131     CSPLOGSTRING(CSPINT, "CSPEtelCallRequester::MakeDialEmergencyRequest" );

   132     Cancel();

   133 

   134     iRequestType = ERequestTypeDialEmergency;

   135     iCall.DialEmergencyCall( iStatus, aRecipient );

   136     SetActive();

   137     

   138     return KErrNone;

   139     }

   140 

   141 // ---------------------------------------------------------------------------

   142 // CSPEtelCallRequester::MakeRequest

   143 // ---------------------------------------------------------------------------

   144 //

   145 TInt CSPEtelCallRequester::MakeRequest( TRequestType aRequest )

   146     {

   147     TInt result = KErrUnknown;

   148 

   149     if ( !IsActive() )

   150         {

   151         if ( aRequest != ERequestTypeDial 

   152              && aRequest != ERequestTypeDialEmergency )

   153             {

   154             iRequestType = aRequest;

   155             }

   156         CSPLOGSTRING2( CSPREQOUT, 

   157             "CSP: CSPEtelCallRequester::MakeRequest %d", iRequestType );

   158         switch ( aRequest )

   159             {

   160             case ERequestTypeDial:

   161                 {

   162                 // Requested through MakeDialRequest as a special case because

   163                 // of the parameters.

   164                 result = KErrNotSupported;

   165                 break;

   166                 }

   167             case ERequestTypeDialEmergency:

   168                 {

   169                 // Requested through MakeDialEmergencyRequest as a special case because

   170                 // of the parameters.

   171                 result = KErrNotSupported;

   172                 break;

   173                 }

   174             case ERequestTypeAnswer:

   175                 {

   176                 iCall.AnswerIncomingCall( iStatus );

   177                 result = KErrNone;

   178                 SetActive();

   179                 break;

   180                 }                

   181             case ERequestTypeHangup:

   182                 {

   183                 iCall.HangUp( iStatus );

   184                 SetActive();

   185                 result = KErrNone;

   186                 break;

   187                 }

   188             case ERequestTypeHold:

   189                 {

   190                 iCall.Hold( iStatus );

   191                 SetActive();

   192                 result = KErrNone;

   193                 break;

   194                 }

   195             case ERequestTypeResume:

   196                 {

   197                 iCall.Resume( iStatus );

   198                 SetActive();

   199                 result = KErrNone;

   200                 break;

   201                 }

   202             case ERequestTypeGoOneToOne:

   203                 {

   204                 iCall.GoOneToOne( iStatus );

   205                 SetActive();

   206                 result = KErrNone;

   207                 break;

   208                 }

   209             case ERequestTypeSwap:

   210                 {

   211                 iCall.Swap( iStatus );

   212                 SetActive();

   213                 result = KErrNone;

   214                 break;

   215                 }

   216                 

   217             default:

   218                 {

   219                 CSPLOGSTRING2( CSPERROR, 

   220                     "CSP: CSPEtelCallRequester::MakeRequest: Unspecified \

   221                                         request type: %d", iRequestType );

   222                 result = KErrArgument;

   223                 }

   224             }        

   225         }

   226     else

   227         {

   228         CSPLOGSTRING( CSPERROR, 

   229             "CSP: CSPEtelCallRequester::MakeRequest: Already active" );

   230         result = KErrInUse;

   231         }

   232         

   233     return result;

   234     }

   235 

   236 // ---------------------------------------------------------------------------

   237 // CSPEtelCallRequester::CancelRequest

   238 // ---------------------------------------------------------------------------

   239 //

   240 TInt CSPEtelCallRequester::CancelRequest( TRequestType aRequest )

   241     {

   242     TInt result(KErrNone);

   243     if ( iRequestType == aRequest )

   244         {

   245         Cancel();

   246         }

   247     else

   248         {

   249         CSPLOGSTRING3( CSPERROR, "CSPEtelCallRequester::CancelRequest: No such active, current is %d, param=%d", iRequestType, aRequest );

   250         result = KErrNotReady;

   251         }

   252     return result;

   253     }

   254 

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

   256 // From CActive

   257 // CSPEtelCallRequester::RunL

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

   259 //

   260 void CSPEtelCallRequester::RunL()

   261     {

   262     CSPLOGSTRING2( CSPREQEND, "CSPEtelCallRequester::RunL: status: %d", iStatus.Int() );

   263     

   264     TRequestType endedRequest = iRequestType;

   265     iRequestType = ERequestTypeNone;

   266     if ( iStatus == KErrNone )

   267         {

   268         

   269         switch ( endedRequest )

   270             {            

   271             case ERequestTypeDial:

   272                 {

   273                 CSPLOGSTRING( CSPINT, 

   274                     "CSP CSPEtelCallRequester::RunL: Dial request OK" );

   275                 break;

   276                 }

   277             case ERequestTypeAnswer:

   278                 {

   279                 CSPLOGSTRING( CSPINT, 

   280                     "CSP CSPEtelCallRequester::RunL: Answer request OK" );

   281                 break;

   282                 }

   283             case ERequestTypeHangup:

   284                 {

   285                 CSPLOGSTRING( CSPINT, 

   286                     "CSP CSPEtelCallRequester::RunL: Hangup request OK" );

   287                 break;

   288                 }

   289             case ERequestTypeHold:

   290                 {

   291                 CSPLOGSTRING( CSPINT, 

   292                     "CSP CSPEtelCallRequester::RunL: Hold request OK" );

   293                 break;

   294                 }

   295             case ERequestTypeResume:

   296                 {

   297                 CSPLOGSTRING( CSPINT, 

   298                     "CSP CSPEtelCallRequester::RunL: Resume request OK" );

   299                 break;

   300                 }

   301             case ERequestTypeGoOneToOne:

   302                 {

   303                 CSPLOGSTRING( CSPINT, 

   304                     "CSP CSPEtelCallRequester::RunL: GoOneToOne request OK" );

   305                 break;

   306                 }

   307             case ERequestTypeSwap:

   308                 {

   309                 CSPLOGSTRING( CSPINT, 

   310                     "CSP CSPEtelCallRequester::RunL: Swap request OK" );

   311                 break;

   312                 }

   313             case ERequestTypeDialEmergency:

   314                 {

   315                 CSPLOGSTRING( CSPINT,

   316                 "CSP CSPEtelCallRequester::RunL: DialEmergency request OK" );

   317                 break;

   318                 }

   319             default:

   320                 {

   321                 CSPLOGSTRING2( CSPERROR, 

   322                     "CSP CSPEtelCallRequester::RunL: Unspecified request \

   323                                                 type: %d", iRequestType );

   324                 break;

   325                 }

   326             }

   327         }

   328     else

   329         {

   330         // Error situations

   331         TInt err = iStatus.Int();

   332         CSPLOGSTRING2( CSPERROR, "CSP CSPEtelCallRequester::RunL: request \

   333                                 completed with error: %d", err );

   334 

   335         switch ( endedRequest )

   336             {

   337             case ERequestTypeDial:

   338                 {

   339                 CSPLOGSTRING( CSPINT, 

   340                     "CSP CSPEtelCallRequester::RunL: Dial request" );

   341                 if ( err != KErrCancel )

   342                     {

   343                     iObserver.DialRequestFailed( err );

   344                     return; // In case of Idle state has caused

   345                     // immediate destruction of this object.

   346                     }

   347                 break;

   348                 }

   349             case ERequestTypeAnswer:

   350                 {

   351                 CSPLOGSTRING( CSPINT, 

   352                     "CSP CSPEtelCallRequester::RunL: Answer request" );

   353                 iObserver.NotifyErrorOccurred( ECCPRequestFailure );

   354                 break;

   355                 }

   356             case ERequestTypeHangup:

   357                 {

   358                 CSPLOGSTRING( CSPINT, 

   359                     "CSP CSPEtelCallRequester::RunL: Hangup request" );

   360                 iObserver.NotifyErrorOccurred( ECCPRequestFailure );

   361                 break;

   362                 }

   363             case ERequestTypeHold:

   364                 {

   365                 CSPLOGSTRING( CSPINT, 

   366                     "CSP CSPEtelCallRequester::RunL: Hold request" );

   367                 iObserver.NotifyErrorOccurred( ECCPLocalHoldFail );

   368 

   369                 break;

   370                 }

   371             case ERequestTypeResume:

   372                 {

   373                 CSPLOGSTRING( CSPINT, 

   374                     "CSP CSPEtelCallRequester::RunL: Resume request" );

   375                 iObserver.NotifyErrorOccurred( ECCPLocalResumeFail );

   376                 break;

   377                 }

   378             case ERequestTypeGoOneToOne:

   379                 {

   380                 CSPLOGSTRING( CSPINT, 

   381                     "CSP CSPEtelCallRequester::RunL: GoOneToOne request" );

   382                 iObserver.NotifyErrorOccurred( ECCPRequestFailure );

   383                 break;

   384                 }

   385             case ERequestTypeSwap:

   386                 {

   387                 CSPLOGSTRING( CSPINT, 

   388                     "CSP CSPEtelCallRequester::RunL: Swap request" );

   389                 iObserver.NotifyErrorOccurred( ECCPRequestFailure );

   390                 break;

   391                 }

   392             case ERequestTypeDialEmergency:

   393                 {

   394                 CSPLOGSTRING2( CSPINT,

   395                     "CSP CSPEtelCallRequester: RunL: DialEmergency error: %d",

   396                      err );

   397                 

   398                 if ( err != KErrCancel )

   399                     {

   400                     iObserver.EmergencyDialRequestFailed(err);

   401                     }

   402                 

   403                 break;

   404                 }

   405                 

   406             default:

   407                 {

   408                 CSPLOGSTRING2( CSPERROR, 

   409                     "CSP CSPEtelCallRequester::RunL: Unspecified request \

   410                                                 type: %d", iRequestType );

   411                 break;

   412                 }

   413             }

   414         

   415         }    

   416     }

   417 

   418 

   419 // ---------------------------------------------------------------------------

   420 // From CActive

   421 // CSPEtelCallRequester::DoCancel

   422 // ---------------------------------------------------------------------------

   423 //

   424 void CSPEtelCallRequester::DoCancel()

   425     {

   426     CSPLOGSTRING( CSPREQOUT, "CSP: CSPEtelCallRequester::DoCancel" );

   427     TRequestType cancelRequest = iRequestType;

   428     iRequestType = ERequestTypeNone;

   429     

   430     if ( IsActive() )

   431         {

   432         CSPLOGSTRING( CSPREQOUT, "CSP: CSPEtelCallRequester::DoCancel IsActive" );

   433         switch ( cancelRequest )

   434             {

   435             case ERequestTypeDial:

   436                 {

   437                 CSPLOGSTRING( CSPREQOUT, "CSPEtelCallRequester::DoCancel DialCancel" );

   438                 iCall.DialCancel();

   439                 CSPLOGSTRING( CSPREQOUT, "CSPEtelCallRequester::DoCancel DialCancel OK" );

   440                 break;

   441                 }

   442             case ERequestTypeAnswer:

   443                 {

   444                 iCall.AnswerIncomingCallCancel();

   445                 break;

   446                 }

   447             case ERequestTypeHangup:

   448                 {

   449                 iCall.HangUpCancel();

   450                 break;

   451                 }

   452             case ERequestTypeHold:

   453                 {

   454                 iCall.CancelAsyncRequest( EMobileCallHold );

   455                 break;

   456                 }

   457             case ERequestTypeResume:

   458                 {

   459                 iCall.CancelAsyncRequest( EMobileCallResume );

   460                 break;

   461                 }

   462             case ERequestTypeGoOneToOne:

   463                 {

   464                 iCall.CancelAsyncRequest( EMobileCallGoOneToOne );

   465                 break;

   466                 }

   467             case ERequestTypeSwap:

   468                 {

   469                 iCall.CancelAsyncRequest( EMobileCallSwap );

   470                 break;

   471                 }

   472             case ERequestTypeDialEmergency:

   473                 {

   474                 iCall.CancelAsyncRequest( EMobileCallDialEmergencyCall );

   475                 break;

   476                 }

   477             default:

   478                 {

   479                 CSPLOGSTRING2( CSPERROR, "CSP CSPEtelCallRequester::DoCancel: \

   480                                 Unspecified request type: %d", iRequestType );

   481                 }

   482             }

   483         }

   484     else

   485         {

   486         CSPLOGSTRING( CSPERROR, 

   487             "CSP: CSPEtelCallRequester::DoCancel: Not active" );

   488         }    

   489     }

   490 

   491 // ---------------------------------------------------------------------------

   492 // Constructs the requester.

   493 // ---------------------------------------------------------------------------

   494 //

   495 CSPEtelCallRequester::CSPEtelCallRequester(

   496             MCSPCallErrorObserver& aObserver,

   497             RMobileCall& aCall ) : 

   498                 CActive( EPriorityStandard ), 

   499                 iObserver( aObserver ), 

   500                 iCall ( aCall ),

   501                 iRequestType( ERequestTypeNone )

   502     {

   503     CSPLOGSTRING(CSPOBJECT, "CSPEtelCallRequester::CSPEtelCallRequester()" );

   504     CActiveScheduler::Add( this );

   505     }

   506 

   507 // ---------------------------------------------------------------------------

   508 // Error value mapping.

   509 // ---------------------------------------------------------------------------

   510 //

   511 TCCPError CSPEtelCallRequester::MapError( TInt aErrorCode )

   512     {

   513     TCCPError ret = ECCPRequestFailure;

   514     CSPLOGSTRING2( CSPINT, "CSPEtelCallRequester::MapError %d", aErrorCode);

   515        

   516     switch ( aErrorCode )

   517         {

   518         case KErrGsmCCUnassignedNumber:

   519             {

   520             ret = ECCPErrorNotReached;

   521             break;

   522             }        

   523         case KErrGsmCCUserBusy:

   524             {

   525             ret = ECCPErrorBusy;

   526             break;

   527             }

   528         case KErrMMEtelCallForbidden:

   529         case KErrGsmCallInProgress:

   530         case KErrGsmNumberBarred:

   531         case KErrGsmNotAllowed:

   532         case KErrEtelCallNotActive:

   533         case KErrEtelCallAlreadyActive:

   534             {

   535             ret = ECCPErrorNotAllowed;

   536             break;

   537             }        

   538         case KErrGsmCCNumberChanged:

   539             {

   540             ret = ECCPErrorMovedPermanently;

   541             break;

   542             }        

   543         case KErrGsmCCInvalidNumberFormat:

   544             {

   545             ret = ECCPErrorInvalidURI;

   546             break;

   547             }        

   548         case KErrGsmCCNormalUnspecified:

   549             {

   550             ret = ECCPErrorNoAnswerForVideo;

   551             break;

   552             }

   553         case KErrGsmCCTemporaryFailure:

   554         case KErrGsmCCSwitchingEquipmentCongestion:

   555         case KErrGsmCCRequestedChannelNotAvailable:

   556             {

   557             ret = ECCPErrorNetworkBusy;

   558             break;

   559             }     

   560         case KErrGsmCCNetworkOutOfOrder:

   561             {

   562             ret = ECCPErrorNetworkOutOfOrder;

   563             break;

   564             }     

   565         case KErrGsmCCRequestedFacilityNotSubscribed:

   566             {

   567             ret = ECCPErrorCCRequestedFacilityNotSubscribed;

   568             break;

   569             } 

   570         case KErrGsmCCInvalidCallReferenceValue:

   571             {

   572             ret = ECCPErrorInvalidCallReferenceValue;

   573             break;

   574             } 

   575         case KErrGsmCCUserNotInCug:

   576             {

   577             ret = ECCPErrorUserNotInCug;

   578             break;

   579             }

   580         case KErrGsmCCIncompatibleDestination:

   581             {

   582             // Affects to phone redial handling

   583             ret = ECCPErrorBadRequest;

   584             break;

   585             }

   586         case KErrGsmCCInvalidTransitNetworkSelection:

   587             {

   588             ret = ECCPErrorCCInvalidTransitNetworkSelection;

   589             break;

   590             }

   591         case KErrGsmCCSemanticallyIncorrectMessage:

   592         case KErrGsmCCConditionalIEError:

   593         case KErrGsmCCUnspecifiedProtocolError:

   594         case KErrEtelNoCarrier:

   595             {

   596             ret = ECCPErrorConnectionError;

   597             break;

   598             }

   599         case KErrGsmCallServerFail:

   600         case KErrGsm0707NotFound:

   601         case KErrGsmCallRejected:

   602             {

   603             ret = ECCPErrorRejected;

   604             break;

   605             }

   606         case KErrGeneral:

   607             {

   608             ret = ECCPErrorGeneral;

   609             break;

   610             }

   611         case KErrNotSupported:

   612             {

   613             ret = ECCPErrorNotSupported;

   614             break;

   615             }

   616         case KErrNoMemory:

   617             {

   618             ret = ECCPErrorNoMemory;

   619             break;

   620             }

   621         case KErrInUse:

   622             {

   623             ret = ECCPErrorAlreadyInUse;

   624             break;

   625             }

   626         case KErrNotReady:

   627             {

   628             ret = ECCPErrorNotReady;

   629             break;

   630             }

   631         case KErrGsmNoService:

   632             {

   633             ret = ECCPErrorNoService;

   634             break;

   635             }

   636         case KErrGsmOfflineOpNotAllowed:

   637             {

   638             ret = ECCPErrorNotAllowedInOfflineMode;

   639             break;

   640             }

   641         case KErrDiagnosticInfoBarredWithCUG:

   642             {

   643             ret = ECCPErrorCUGOutgoingCallsBarred;

   644             break;

   645             }

   646         case KErrDiagnosticInfoBarredNoCUG:

   647             {

   648             ret = ECCPErrorCUGNotSelected;

   649             break;

   650             }

   651         case KErrDiagnosticInfoBarredUnknownCUG:

   652             {

   653             ret = ECCPErrorCUGIndexUnknown;

   654             break;

   655             }

   656         case KErrDiagnosticInfoBarredIncompatibleCUG:

   657             {

   658             ret = ECCPErrorCUGIndexIncompatible;

   659             break;

   660             }

   661         case KErrDiagnosticInfoBarredFailureCUG:

   662             {

   663             ret = ECCPErrorCUGCallsFailure;

   664             break;

   665             }

   666         case KErrDiagnosticInfoBarredClirNotSubscribed:

   667             {

   668             ret = ECCPErrorCLIRNotSubscribed;

   669             break;

   670             }

   671         case KErrDiagnosticInfoBarredCCBSPossible:

   672             {

   673             ret = ECCPErrorCCBSPossible;

   674             break;

   675             }            

   676         case KErrDiagnosticInfoBarredCCBSNotPossible:

   677             {

   678             ret = ECCPErrorCCBSNotPossible;

   679             break;

   680             }            

   681         case KErrGsmCCRequestedFacilityNotImplemented:

   682             {

   683             ret = ECCPErrorServiceSettingError;

   684             break;

   685             }

   686         case KErrGsm0707SimNotInserted:

   687         case KErrGsm0707SIMPuk1Required:

   688         case KErrGsm0707SimPin1Required:

   689         case KErrGsm0707SimPin2Required:

   690         case KErrGsm0707SimFailure:

   691         case KErrGsm0707PhoneToSimLockRequired:

   692         case KErrGsm0707SimWrong:

   693             {

   694             ret = ECCPErrorAuthenticationFailed;

   695             break;

   696             }            

   697         case KErrGsmInvalidFdn:

   698             {

   699             ret = ECCPErrorInvalidFDN;

   700             break;

   701             }

   702         case KErrArgument:

   703             {

   704             ret = ECCPErrorInvalidPhoneNumber;

   705             break;

   706             }

   707         case KErrGsmCCOperatorDeterminedBarring:

   708             {

   709             ret = ECCPErrorNumberBarred;

   710             break;

   711             }

   712         case KErrGsmCCChannelUnacceptable:

   713             {

   714             ret = ECCPErrorUnacceptableChannel;

   715             break;

   716             }

   717         case KErrGsmCCAccessInformationDiscarded:

   718             {

   719             ret = ECCPErrorAccessInformationDiscarded;

   720             break;

   721             }

   722         case KErrGsmCCQualityOfServiceNotAvailable:

   723             {

   724             ret = ECCPErrorQualityOfServiceNotAvailable;

   725             break;

   726             }

   727         case KErrAccessDenied:

   728             {

   729             ret = ECCPErrorAccessDenied;

   730             break;

   731             }

   732         case KErrGsmCCNoRouteToDestination:

   733             {

   734             ret = ECCPErrorCCNoRouteToDestination;

   735             break;

   736             }

   737         case KErrGsmCCDestinationOutOfOrder:

   738             {

   739             ret = ECCPErrorCCDestinationOutOfOrder;

   740             break;

   741             }

   742         case KErrGsmCCResourceNotAvailable:

   743             {

   744             ret = ECCPErrorCCResourceNotAvailable;

   745             break;

   746             }

   747         case KErrGsmCCIncompatibleMessageInCallState:

   748             {

   749             ret = ECCPErrorCCIncompatibleMessageInCallState;

   750             break;

   751             }

   752         case KErrGsmCCNormalCallClearing:

   753             {

   754             ret = ECCPErrorCCNormalCallClearing;

   755             break;

   756             }

   757         case KErrGsmCCUserNotResponding:

   758             {

   759             ret = ECCPErrorCCUserNotResponding;

   760             break;

   761             }

   762         case KErrGsmCCUserAlertingNoAnswer:

   763             {

   764             ret = ECCPErrorCCUserAlertingNoAnswer;

   765             break;

   766             }

   767         case KErrGsmCCCallRejected:

   768             {

   769             ret = ECCPErrorCCCallRejected;

   770             break;

   771             }

   772         case KErrGsmCCPreemption:

   773             {

   774             ret = ECCPErrorCCPreemption;

   775             break;

   776             }

   777         case KErrGsmCCFacilityRejected:

   778             {

   779             ret = ECCPErrorCCFacilityRejected;

   780             break;

   781             }

   782         case KErrGsmCCResponseToStatusEnquiry:

   783             {

   784             ret = ECCPErrorCCResponseToStatusEnquiry;

   785             break;

   786             }

   787         case KErrGsmCCInvalidMandatoryInformation:

   788             {

   789             ret = ECCPErrorCCInvalidMandatoryInformation;

   790             break;

   791             }

   792         case KErrGsmCCNonExistentMessageType:

   793             {

   794             ret = ECCPErrorCCNonExistentMessageType;

   795             break;

   796             }

   797         case KErrGsmCCIncompatibleMessageInProtocolState:

   798             {

   799             ret = ECCPErrorCCIncompatibleMessageInProtocolState;

   800             break;

   801             }

   802         case KErrGsmCCNonExistentInformationElement:

   803             {

   804             ret = ECCPErrorCCNonExistentInformationElement;

   805             break;

   806             }

   807         case KErrGsmCCRecoveryOnTimerExpiry:

   808             {

   809             ret = ECCPErrorCCRecoveryOnTimerExpiry;

   810             break;

   811             }

   812         case KErrGsmCCNoChannelAvailable:

   813             {

   814             ret = ECCPErrorCCNoChannelAvailable;

   815             break;

   816             }

   817         case KErrGsmCCIncomingCallsBarredInCug:

   818             {

   819             ret = ECCPErrorCCIncomingCallsBarredInCug;

   820             break;

   821             }

   822         case KErrGsmCCBearerCapabilityNotAuthorised:

   823             {

   824             ret = ECCPErrorCCBearerCapabilityNotAuthorised;

   825             break;

   826             }

   827         case KErrGsmCCBearerCapabilityNotCurrentlyAvailable:

   828             {

   829             ret = ECCPErrorCCBearerCapabilityNotCurrentlyAvailable;

   830             break;

   831             }

   832         case KErrGsmCCServiceNotAvailable:

   833             {

   834             ret = ECCPErrorCCServiceNotAvailable;

   835             break;

   836             }

   837         case KErrGsmCCBearerServiceNotImplemented:

   838             {

   839             ret = ECCPErrorCCBearerServiceNotImplemented;

   840             break;

   841             }

   842         case KErrGsmCCOnlyRestrictedDigitalInformationBCAvailable:

   843             {

   844             ret = ECCPErrorCCOnlyRestrictedDigitalInformationBCAvailable;

   845             break;

   846             }

   847         case KErrGsmCCServiceNotImplemented:

   848             {

   849             ret = ECCPErrorCCOnlyRestrictedDigitalInformationBCAvailable;

   850             break;

   851             }

   852         case KErrGsmCCUnspecifiedInterworkingError:

   853             {

   854             ret = ECCPErrorCCUnspecifiedInterworkingError;

   855             break;

   856             }

   857         case KErrGsmNoNumber:

   858             {

   859             ret = ECCPErrorInvalidPhoneNumberCancelRedial;

   860             break;

   861             }

   862         case KErrNotFound:

   863             {

   864             ret = ECCPErrorNotFound;

   865             break;

   866             }

   867         case KErrTimedOut:

   868             {

   869             ret = ECCPErrorTimedOut;

   870             break;

   871             }

   872         case KErrGsmReleaseByUser:

   873             {

   874             ret = ECCPErrorReleaseByUserForCancelRedial;

   875             break;

   876             }

   877         case KErrSatControl:

   878             {

   879             ret = ECCPErrorSatControl;

   880             break;

   881             }

   882         default:

   883             {

   884             // Use the predefined.

   885             break;

   886             }

   887         }

   888     return ret;

   889     }

   890 

   891 // ---------------------------------------------------------------------------

   892 // Returns the active request.

   893 // ---------------------------------------------------------------------------

   894 //

   895 CSPEtelCallRequester::TRequestType CSPEtelCallRequester::Request()

   896     {

   897     if ( IsActive() )

   898         {

   899         return iRequestType;

   900         }

   901     

   902     return ERequestTypeNone;

   903     }

   904     

   905 // ---------------------------------------------------------------------------

   906 // Canceling emergency or normal call dial request.

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

   908 //

   909 TInt CSPEtelCallRequester::DialCancel() 

   910     {

   911     TInt ret = KErrNotReady;

   912     if ( iRequestType == ERequestTypeDialEmergency 

   913           || ( iRequestType == ERequestTypeDial ) )

   914         {

   915         ret = CancelRequest( iRequestType );

   916         }

   917     else

   918         {

   919         CSPLOGSTRING2(CSPINT, 

   920           "CSPEtelCallRequester::DialCancel invalid irequest for dialcancel %d",

   921           iRequestType);

   922         }

   923     

   924     return ret;

   925     }

   926 

   927 

   928 // End of File

   929