cellular/telephonysettings/src/PSetCallDivertingBasicImpl.cpp
changeset 46 2fa1fa551b0b
parent 42 35488577e233
child 48 78df25012fda
equal deleted inserted replaced
42:35488577e233 46:2fa1fa551b0b
     1 /*
       
     2 * Copyright (c) 2008-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: Implementation of CPSetCallDivertingBasicImpl class.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 // INCLUDE FILES
       
    20 #include "psetcalldivertingbasicimpl.h" 
       
    21 
       
    22 #include <badesca.h>
       
    23 #include <etelmm.h>           
       
    24 #include <e32math.h>
       
    25 #include <e32svr.h>
       
    26 #include <featmgr.h>
       
    27 #include <centralrepository.h>
       
    28 #include <settingsinternalcrkeys.h> 
       
    29 
       
    30 #include "psetcalldiverting.h" 
       
    31 #include "psetcontainer.h" 
       
    32 #include "mpsetdivertobs.h" 
       
    33 #include "psettelephony.h" 
       
    34 #include "psetpanic.h" 
       
    35 #include "mpsetrequestobs.h" 
       
    36 #include "psetutility.h" 
       
    37 #include "phonesettingslogger.h" 
       
    38 #include "psetsaobserver.h" 
       
    39 
       
    40 //  LOCAL CONSTANTS AND MACROS
       
    41 _LIT( KPSetIntNbr, "+" );
       
    42 _LIT( KPSNameOfClass, "CPSetCallDivertingBasicImpl" );
       
    43 
       
    44 // ============================ MEMBER FUNCTIONS ===============================
       
    45 
       
    46 // -----------------------------------------------------------------------------
       
    47 // CPSetCallDivertingBasicImpl::NewL
       
    48 // Two-phased constructor.
       
    49 // -----------------------------------------------------------------------------
       
    50 //
       
    51 CPSetCallDivertingBasicImpl* CPSetCallDivertingBasicImpl::NewL( 
       
    52         MPsetDivertObserver& aObserver, 
       
    53         RMobilePhone& aPhone,
       
    54         CPsetCallDiverting* aDivert )
       
    55     {
       
    56     CPSetCallDivertingBasicImpl* self = new ( ELeave ) CPSetCallDivertingBasicImpl( aPhone, aDivert );
       
    57     CleanupStack::PushL( self );
       
    58     self->ConstructL( aObserver );
       
    59     CleanupStack::Pop( self );
       
    60     return self;
       
    61     }
       
    62 
       
    63 // ---------------------------------------------------------------------------
       
    64 // CPSetCallDivertingBasicImpl::~CPSetCallDivertingBasicImpl
       
    65 // ---------------------------------------------------------------------------
       
    66 //
       
    67 CPSetCallDivertingBasicImpl::~CPSetCallDivertingBasicImpl()
       
    68     {
       
    69     }
       
    70 
       
    71 // -----------------------------------------------------------------------------
       
    72 // CPSetCallDivertingBasicImpl::CPSetCallDivertingBasicImpl
       
    73 // C++ constructor can NOT contain any code, that
       
    74 // might leave.
       
    75 // -----------------------------------------------------------------------------
       
    76 //
       
    77 CPSetCallDivertingBasicImpl::CPSetCallDivertingBasicImpl( 
       
    78                     RMobilePhone& aPhone, CPsetCallDiverting* aDivert ) : 
       
    79                     CPSetCallDivertingBase( aPhone, aDivert )
       
    80     {
       
    81     }
       
    82 
       
    83 // -----------------------------------------------------------------------------
       
    84 // CPSetCallDivertingBasicImpl::ConstructL
       
    85 // Symbian 2nd phase constructor can leave.
       
    86 // -----------------------------------------------------------------------------
       
    87 //
       
    88 void CPSetCallDivertingBasicImpl::ConstructL( MPsetDivertObserver& aObserver )
       
    89     {
       
    90     CPSetCallDivertingBase::ConstructL( aObserver );
       
    91     }
       
    92 
       
    93 // -----------------------------------------------------------------------------
       
    94 // CPSetCallDivertingBasicImpl::ConstructL
       
    95 // Symbian 2nd phase constructor can leave.
       
    96 // -----------------------------------------------------------------------------
       
    97 //
       
    98 void CPSetCallDivertingBasicImpl::SetDivertingL( const TCallDivertSetting& aDivert,  TBasicServiceGroups aBsc )
       
    99     {
       
   100     __PHSLOGSTRING("[PHS]--> CPSetCallDivertingBasicImpl::SetDivertingL");
       
   101     __PHSLOGSTRING1("[PHS]    CPSetCallDivertingBasicImpl::SetDivertingL: aBsc: %d", aBsc );
       
   102    if ( IsActive() )
       
   103        {
       
   104        User::Leave( KErrInUse );
       
   105        }
       
   106    iBsc = aBsc;
       
   107    iRequestedServiceGroup = aDivert.iServiceGroup;
       
   108    
       
   109    CPsetTelephony::CheckLineModeL( aDivert.iServiceGroup, &iPhone, iLine );
       
   110    if ( !iLine->SubSessionHandle() )
       
   111        {
       
   112        User::Leave( KErrBadHandle );
       
   113        }
       
   114        
       
   115    SetRequestStatus( EPSetChangeDivert );
       
   116    iReason = PSetUtility::GetDivertReason ( aDivert.iCondition );
       
   117    iVoiceDivert = SetVoiceDivert( aDivert, aBsc );
       
   118 
       
   119    ValidateBsc( aBsc );
       
   120    iPluralNotes = IsMultiAffectingDivert( aDivert, aBsc );
       
   121 
       
   122    //Copy data to member variable
       
   123    iChangeInfo.iNumber.iTelNumber.Copy( aDivert.iNumber );
       
   124    iChangeInfo.iTimeout = KPSetDefaultDelayTimeValue;
       
   125    if ( aBsc == EAltTele )
       
   126        {
       
   127        iChangeInfo.iServiceGroup = PSetUtility::VerifyAltLineUseL();
       
   128        }
       
   129    iChangeInfo.iServiceGroup = PSetUtility::ChangeToEtelInternal( aBsc ); 
       
   130    iChangeInfo.iNumber.iNumberPlan = RMobilePhone::EIsdnNumberPlan;
       
   131    iChangeInfo.iNumber.iTypeOfNumber = RMobilePhone::EUnknownNumber;
       
   132    if ( iChangeInfo.iNumber.iTelNumber.Length() > 0 )
       
   133        {
       
   134        if ( iChangeInfo.iNumber.iTelNumber.Left(1) == KPSetIntNbr )
       
   135            {
       
   136            iChangeInfo.iNumber.iTypeOfNumber = 
       
   137                RMobilePhone::EInternationalNumber;
       
   138            }
       
   139        }
       
   140 
       
   141    switch ( aDivert.iSetting )
       
   142        {
       
   143        case ERegisterDiverting:
       
   144           /*****************************************************
       
   145           *    Series 60 Customer / ETel
       
   146           *    Series 60  ETel API
       
   147           *****************************************************/
       
   148           iChangeInfo.iAction = RMobilePhone::EServiceActionRegister;
       
   149           iChangeInfo.iTimeout = aDivert.iNoReplyTimer;
       
   150           __PHSLOGSTRING("[PHS]    CPSetCallDivertingBasicImpl::SetDivertingL: ERegisterDiverting" );
       
   151           break;
       
   152        case EEraseDiverting:
       
   153            iChangeInfo.iAction = RMobilePhone::EServiceActionErase;
       
   154            __PHSLOGSTRING("[PHS]    CPSetCallDivertingBasicImpl::SetDivertingL: EEraseDiverting" );
       
   155            break;
       
   156        case EActivateDiverting:
       
   157            iChangeInfo.iAction = RMobilePhone::EServiceActionActivate;
       
   158            iChangeInfo.iTimeout = aDivert.iNoReplyTimer;
       
   159            __PHSLOGSTRING("[PHS]    CPSetCallDivertingBasicImpl::SetDivertingL: EActivateDiverting" );
       
   160            break;
       
   161        case ECancelDiverting:
       
   162            iChangeInfo.iAction = RMobilePhone::EServiceActionDeactivate;
       
   163            __PHSLOGSTRING("[PHS]    CPSetCallDivertingBasicImpl::SetDivertingL: ECancelDiverting" );
       
   164            break;
       
   165        default:
       
   166            User::Leave( KErrArgument );
       
   167            break;
       
   168        }
       
   169 
       
   170    //Start requesting for setting Divert.
       
   171    iPhone.SetCallForwardingStatus( iStatus, iReason, iChangeInfo );
       
   172    StartRequestingL( KPsetRequestAlreadySet );    
       
   173    __PHSLOGSTRING("[PHS] <--CPSetCallDivertingBasicImpl::SetDivertingL" );
       
   174    }
       
   175 
       
   176 // ---------------------------------------------------------------------------
       
   177 // RunL
       
   178 // ---------------------------------------------------------------------------
       
   179 //
       
   180 void CPSetCallDivertingBasicImpl::RunL()
       
   181     {
       
   182     __PHSLOGSTRING("[PHS]--> CPSetCallDivertingBasicImpl::RunL" );           
       
   183    __ASSERT_ALWAYS( 
       
   184        iObserver != NULL, Panic( KPSNameOfClass, ECDRequestPanicNoObserver ) );
       
   185 
       
   186    //Hide requesting note - does not leave when deleting a note.
       
   187    iObserver->SetEngineContact( iDivert );
       
   188    iObserver->HandleCFRequestingL( EFalse, EFalse );
       
   189 
       
   190    //Handle error case.
       
   191    if ( iStatus != KErrNone )
       
   192        {
       
   193        iObserver->HandleDivertingErrorL( iStatus.Int() );
       
   194        RequestCompleted( iStatus.Int() );
       
   195        return;
       
   196        }
       
   197        
       
   198    iDivertStatus.Initialize();
       
   199    switch ( iCurrentReq )
       
   200        {
       
   201        case EPSetChangeDivert:
       
   202            {
       
   203            __PHSLOGSTRING("[PHS]--> CPSetCallDivertingBasicImpl::RunL: EPSetChangeDivert" );
       
   204            //Notify Observer            
       
   205            iDivertStatus.iStatus = PSetUtility::GetChangeInfoStatus( iChangeInfo.iAction );
       
   206            iDivertStatus.iNumber = iChangeInfo.iNumber.iTelNumber;
       
   207            iDivertStatus.iCondition = PSetUtility::GetDivertReason(iReason);
       
   208            iDivertStatus.iNoReplyTimer = iChangeInfo.iTimeout;
       
   209            iDivertStatus.iServiceGroup = iRequestedServiceGroup;
       
   210            
       
   211             // Check is done because of VOIP notification functionality(PSetNotesUI).
       
   212            if ( iVoiceDivert && !iVideoDivert )
       
   213                {
       
   214                iDivertStatus.iServiceGroup = EServiceGroupVoice;
       
   215                }
       
   216            
       
   217            iObserver->HandleDivertingChangedL( iDivertStatus, iPluralNotes );
       
   218            
       
   219            //Notify observer.
       
   220            HandleSANotificationL( 
       
   221                IsVMBXDivertL( iChangeInfo.iNumber.iTelNumber ), 
       
   222                iDivertStatus.iStatus );
       
   223            break;
       
   224            }
       
   225        case EPSetGetDivertStatus:
       
   226            {
       
   227            __PHSLOGSTRING("[PHS]--> CPSetCallDivertingBasicImpl::RunL: EPSetGetDivertStatus" );
       
   228 
       
   229            CMobilePhoneCFList* cfList = iCfInterrogator->RetrieveListL();
       
   230            CleanupStack::PushL( cfList );
       
   231            CMobilePhoneCFList* cleanedList = CMobilePhoneCFList::NewL();            
       
   232            CleanupStack::PushL( cleanedList );
       
   233            
       
   234            TInt numOfItems = cfList->Enumerate();
       
   235            TInt index = 0;
       
   236            RMobilePhone::TMobilePhoneCFInfoEntryV1 cfEntry;
       
   237            RMobilePhone::TMobilePhoneCFInfoEntryV1 copy;
       
   238            iDivertStatus.iStatus = EDivertingStatusNotRegistered;
       
   239            while( index < numOfItems )
       
   240                {
       
   241                cfEntry = cfList->GetEntryL( index );
       
   242                iBsc = PSetUtility::ChangeToGSM( cfEntry.iServiceGroup );
       
   243 
       
   244                if ( cfEntry.iStatus == RMobilePhone::ECallForwardingStatusActive )
       
   245                    {
       
   246                    copy.iServiceGroup = cfEntry.iServiceGroup;
       
   247                    copy.iCondition = cfEntry.iCondition;
       
   248                    copy.iStatus = cfEntry.iStatus;
       
   249                    copy.iNumber = cfEntry.iNumber;
       
   250                    copy.iTimeout = cfEntry.iTimeout;
       
   251                    cleanedList->AddEntryL( copy );
       
   252                    }
       
   253                    
       
   254                 __PHSLOGSTRING1("[PHS] CPSetCallDivertingBasicImpl::RunL: EPSetGetDivertStatus     iBsc: %d", iBsc );
       
   255                 __PHSLOGSTRING1("[PHS] CPSetCallDivertingBasicImpl::RunL: EPSetGetDivertStatus iStatus: %d", cfEntry.iStatus );
       
   256                if ( iBsc == EAllTeleAndBearer || iBsc == EAllTele || iBsc == ETelephony || iBsc == EAltTele ||
       
   257                    iBsc == EAllBearer || iBsc == EAllSync || iBsc == ESyncData )
       
   258                    {
       
   259                    // iVoiceDivert is set to true to ensure that the icons are updated in every case.
       
   260                    iVoiceDivert = ETrue;
       
   261                    if ( ( cfEntry.iStatus != RMobilePhone::ECallForwardingStatusNotRegistered )
       
   262                        && ( cfEntry.iStatus != RMobilePhone::ECallForwardingStatusNotActive )
       
   263                        && ( cfEntry.iStatus != RMobilePhone::ECallForwardingStatusNotProvisioned ) )
       
   264                        {
       
   265                        iDivertStatus.iStatus = EDivertingStatusActive;
       
   266                        }
       
   267                    else
       
   268                        {
       
   269                        iDivertStatus.iStatus = EDivertingStatusNotRegistered;
       
   270                        }
       
   271                    
       
   272                    HandleSANotificationL( 
       
   273                            IsVMBXDivertL( cfEntry.iNumber.iTelNumber ), 
       
   274                            iDivertStatus.iStatus );
       
   275                    }
       
   276                index++;
       
   277                }
       
   278            if ( cleanedList->Enumerate() == 0 )
       
   279                {
       
   280                iObserver->HandleDivertingStatusL( *cfList, iPluralNotes );
       
   281                }
       
   282            else
       
   283                {
       
   284                iObserver->HandleDivertingStatusL( *cleanedList, iPluralNotes );
       
   285                }
       
   286            CleanupStack::PopAndDestroy( 2 ); //cleanedList, cfList
       
   287            cfList = NULL;
       
   288            cleanedList = NULL;
       
   289            iCFStatusCheck = EFalse; 
       
   290            break;
       
   291            }
       
   292        default:
       
   293            Panic( KPSNameOfClass, ECDRequestPanicIncorrectRequest );
       
   294            break;
       
   295        } 
       
   296     RequestCompleted( KErrNone );
       
   297     __PHSLOGSTRING("[PHS] <--CPSetCallDivertingBasicImpl::RunL" );
       
   298     }    
       
   299 
       
   300 // ---------------------------------------------------------------------------
       
   301 // DoCancel
       
   302 // ---------------------------------------------------------------------------
       
   303 //
       
   304 void CPSetCallDivertingBasicImpl::DoCancel()
       
   305     {
       
   306     __PHSLOGSTRING("[PHS]--> CPSetCallDivertingBasicImpl::DoCancel" );
       
   307     //Decide which request to cancel.
       
   308     switch( iCurrentReq )
       
   309         {
       
   310         case EPSetChangeDivert:
       
   311             __PHSLOGSTRING("[PHS]   DoCancel - EPSetChangeDivert" );
       
   312             iPhone.CancelAsyncRequest( EMobilePhoneSetCallForwardingStatus );
       
   313             break;
       
   314         case EPSetGetDivertStatus:
       
   315             __PHSLOGSTRING("[PHS]   DoCancel - EPSetGetDivertStatus" );
       
   316             iCfInterrogator->Cancel();
       
   317             delete iCfInterrogator;
       
   318             iCfInterrogator = NULL;
       
   319             break;
       
   320         default:
       
   321             break;
       
   322         }
       
   323     
       
   324     //Set current request to none.
       
   325     iCurrentReq = EPSetNone;
       
   326     iVoiceDivert = EFalse;
       
   327     iVideoDivert = EFalse;
       
   328     __PHSLOGSTRING("[PHS]<-- CPSetCallDivertingBasicImpl::DoCancel" );
       
   329     }
       
   330 
       
   331 // ---------------------------------------------------------------------------
       
   332 // RunError
       
   333 // ---------------------------------------------------------------------------
       
   334 //
       
   335 TInt CPSetCallDivertingBasicImpl::RunError( TInt aError ) 
       
   336     {
       
   337     __PHSLOGSTRING1("[PHS]--> CPSetCallDivertingBasicImpl::RunError aError: %d", aError );
       
   338     if ( ( iCurrentReq == EPSetGetDivertStatus || iCurrentReq == EPSetChangeDivert)
       
   339          && iVoiceDivert )
       
   340         {
       
   341         __PHSLOGSTRING("[PHS]   RunError - HandleSANotificationL" );
       
   342         TRAP_IGNORE( HandleSANotificationL( EFalse, iDivertStatus.iStatus ) );
       
   343         }
       
   344         
       
   345     if ( iCurrentReq == EPSetGetDivertStatus )
       
   346         {
       
   347         iCFStatusCheck = EFalse;
       
   348         }   
       
   349     aError = KErrNone;
       
   350         
       
   351     //Set current request to none.
       
   352     iCurrentReq = EPSetNone;    
       
   353     iVoiceDivert = EFalse;
       
   354     iVideoDivert = EFalse;
       
   355     __PHSLOGSTRING("[PHS]<-- CPSetCallDivertingBasicImpl::RunError" );
       
   356     return aError;  
       
   357     }
       
   358 
       
   359 // ---------------------------------------------------------------------------
       
   360 //  If unconditional voice divert is activated/cancelled, notifies observer, 
       
   361 //  so that it can set on/off indicators.
       
   362 // ---------------------------------------------------------------------------
       
   363 //
       
   364 void CPSetCallDivertingBasicImpl::HandleSANotificationL( 
       
   365     TBool aVmbxDivert, TDivertingStatus& aCfStatus )
       
   366     {
       
   367     __PHSLOGSTRING2("[PHS]--> CPSetCallDivertingBasicImpl::HandleSANotificationL aVmbxDivert: %d, aCfStatus: %d", aVmbxDivert, aCfStatus );
       
   368     TBool divertChanged = EFalse;
       
   369 
       
   370     //If divert is not with voice, do not touch indicators.
       
   371     if ( !iVoiceDivert )
       
   372         {
       
   373         return;
       
   374         }
       
   375 
       
   376     //Unconditional divert and all diverts
       
   377     if ( iReason == RMobilePhone::ECallForwardingUnconditional ||
       
   378         iReason == RMobilePhone::ECallForwardingAllCases )
       
   379         {
       
   380         if ( iCurrentReq == EPSetChangeDivert )
       
   381             {
       
   382             //show indicator if, activation/registration, else hide it
       
   383             //these are probably incorrect....
       
   384             divertChanged = 
       
   385                 ( iChangeInfo.iAction == RMobilePhone::EServiceActionRegister ||
       
   386                   iChangeInfo.iAction == RMobilePhone::EServiceActionActivate);
       
   387             }
       
   388         else
       
   389             {
       
   390             //show indicator if status is activated, hide for cancelled.
       
   391             divertChanged = ( aCfStatus == EDivertingStatusActive );
       
   392             }
       
   393         }
       
   394     else
       
   395         {
       
   396         //if not unconditional, do not touch indicators.
       
   397         return;
       
   398         }
       
   399 
       
   400     CPsetSAObserver* systemObserver = CPsetSAObserver::NewL();
       
   401     CleanupStack::PushL( systemObserver );
       
   402     
       
   403     TUnconditionalCFStatus status(KCFIndicatorUnknown);
       
   404     
       
   405     User::LeaveIfError( systemObserver->GetCurrentDivertStatus( status ) );
       
   406     
       
   407     TCallDivertNotifySetting setting = CreateDivertNotifySetting(
       
   408         status, divertChanged, aVmbxDivert, iBsc );
       
   409     
       
   410     // Notify observer that Diverts have changed.
       
   411     systemObserver->NotifyDivertChange( GetSAAls(), 
       
   412         setting,
       
   413         -1 );
       
   414     
       
   415     CleanupStack::PopAndDestroy( systemObserver );
       
   416 
       
   417     __PHSLOGSTRING("[PHS] <--CPSetCallDivertingBasicImpl::HandleSANotificationL" );
       
   418     }
       
   419 
       
   420 // ---------------------------------------------------------------------------
       
   421 // Returns ETrue if divert operation is to voice or to all operations.
       
   422 // ---------------------------------------------------------------------------
       
   423 //
       
   424 TBool CPSetCallDivertingBasicImpl::SetVoiceDivert( const TCallDivertSetting& aDivert,
       
   425     const TBasicServiceGroups aBsc )
       
   426     {
       
   427     iVideoDivert = EFalse;
       
   428     if ( aDivert.iServiceGroup == EServiceGroupVoice ||
       
   429          aDivert.iServiceGroup == EServiceGroupAllTeleservices)
       
   430         {
       
   431         return ETrue;
       
   432         }
       
   433     else if ( ( aDivert.iServiceGroup == EServiceGroupData && ( aBsc == EAllBearer ||
       
   434              aBsc == EAllSync || aBsc == ESyncData ) ) )
       
   435         {
       
   436         iVideoDivert = ETrue;
       
   437         return ETrue;
       
   438         }
       
   439     return EFalse;
       
   440     }
       
   441 
       
   442 // ---------------------------------------------------------------------------
       
   443 // Gets Als information.
       
   444 // ---------------------------------------------------------------------------
       
   445 //
       
   446 TSelectedLine CPSetCallDivertingBasicImpl::GetSAAls()
       
   447     {
       
   448     __PHSLOGSTRING("[PHS]--> CPSetCallDivertingBasicImpl::GetSAAls" );
       
   449     __PHSLOGSTRING2("[PHS] iAls: %d iBsc: %d", iAls, iBsc  );
       
   450     TSelectedLine alsValue = ENotSupportedLine;
       
   451     switch ( iAls )
       
   452         {
       
   453         case ESSSettingsAlsNotSupported:
       
   454             alsValue = ENotSupportedLine;
       
   455             break;
       
   456         case ESSSettingsAlsPrimary:
       
   457             iChangeInfo.iServiceGroup == RMobilePhone::EAuxVoiceService 
       
   458                 ? ( alsValue = EAuxiliaryLine )  
       
   459                 : ( alsValue = EPrimaryLine );
       
   460             break;
       
   461         case ESSSettingsAlsAlternate:
       
   462             alsValue = EAuxiliaryLine;
       
   463             break;
       
   464         default:
       
   465             alsValue = ENotSupportedLine;
       
   466             break;
       
   467         }
       
   468     
       
   469     // If user checks/activates divert to line which is not selected currently than we have
       
   470     // to change returned alsvalue accordinly, if this is not done divert icon status is updated to wrong status.
       
   471     // Example case: Line 2 active user activates divert to line 1: **21*phonenumber*11#.
       
   472     if ( iBsc == EAltTele && iAls == ESSSettingsAlsPrimary )
       
   473         {
       
   474         __PHSLOGSTRING("[PHS]    CPSetCallDivertingBasicImpl::GetSAAls - Line 2 divert activation/check from Line 1" );
       
   475         alsValue = EAuxiliaryLine;
       
   476         }
       
   477     else if ( iBsc == ETelephony && iAls == ESSSettingsAlsAlternate )
       
   478         {
       
   479         __PHSLOGSTRING("[PHS]    CPSetCallDivertingBasicImpl::GetSAAls - Line 1 divert activation/check from Line 2" );
       
   480         alsValue = EPrimaryLine;
       
   481         }
       
   482     
       
   483     __PHSLOGSTRING1("[PHS]    CPSetCallDivertingBasicImpl::GetSAAls: alsValue: %d", alsValue );
       
   484     __PHSLOGSTRING("[PHS] <--CPSetCallDivertingBasicImpl::GetSAAls" );
       
   485     return alsValue;
       
   486     }
       
   487 
       
   488 // End of File