phoneclientserver/phoneclient/Src/EmergencyNumber/EmergencyNumber_Aiw/RPhCltEmergencyCall.cpp
changeset 46 2fa1fa551b0b
parent 42 35488577e233
child 48 78df25012fda
equal deleted inserted replaced
42:35488577e233 46:2fa1fa551b0b
     1 /*
       
     2 * Copyright (c) 2002-2004 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 RPhCltEmergencyCall class.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 // INCLUDE FILES
       
    21 #include    <cphcltemergencycall.h> // for TPhCltEmergencyNumber
       
    22 #include    "rphcltemergencycall.h" 
       
    23 #include    "phcltclientserver.h" 
       
    24 #include    "phcltutils.h" 
       
    25 
       
    26 // CONSTANTS
       
    27 _LIT( KPhCltDtmfCharp, "p" );
       
    28 _LIT( KPhCltDtmfCharw, "w" );
       
    29 _LIT( KPhCltSsCLIRSuppress, "*31#" );    // Outgoing CLI Release (release)
       
    30 _LIT( KPhCltSsCLIRInvoke, "#31#" );   // Outgoing CLI Release (withhold)
       
    31 
       
    32 // Emergency number (number part) max size
       
    33 const TInt KPhCltMaxEmergencyNumberLength = 6; 
       
    34 // Min length of CLIR
       
    35 const TInt KPhCltMinSsStringLength = 4; 
       
    36 
       
    37 // ============================ MEMBER FUNCTIONS ===============================
       
    38 
       
    39 // -----------------------------------------------------------------------------
       
    40 // RPhCltEmergencyCall::RPhCltEmergencyCall
       
    41 // C++ constructor can NOT contain any code, that
       
    42 // might leave.
       
    43 // -----------------------------------------------------------------------------
       
    44 //
       
    45 RPhCltEmergencyCall::RPhCltEmergencyCall() 
       
    46     : RSubSessionBase()
       
    47     {    
       
    48     }
       
    49 
       
    50 // -----------------------------------------------------------------------------
       
    51 // RPhCltEmergencyCall::Open
       
    52 // 
       
    53 // Creates a subsession, as part of the given session.
       
    54 // -----------------------------------------------------------------------------
       
    55 //
       
    56 TInt RPhCltEmergencyCall::Open( RPhCltServer& aServer )
       
    57     {
       
    58     __ASSERT_ALWAYS( aServer.Handle(), User::Panic( 
       
    59         KPhClientPanicCategory, 
       
    60         EPhCltClientSidePanicNullHandle ) );
       
    61 
       
    62     return CreateSubSession( 
       
    63         aServer, 
       
    64         EPhoneServerEmergencyNumberSubSessionOpen,
       
    65         TIpcArgs() );
       
    66     }
       
    67 
       
    68 // -----------------------------------------------------------------------------
       
    69 // RPhCltEmergencyCall::Close
       
    70 // 
       
    71 // Closes the subsession.
       
    72 // -----------------------------------------------------------------------------
       
    73 //
       
    74 void RPhCltEmergencyCall::Close()
       
    75     {
       
    76     CloseSubSession( EPhoneServerEmergencyNumberSubSessionClose );
       
    77     }
       
    78 
       
    79 // -----------------------------------------------------------------------------
       
    80 // RPhCltEmergencyCall::IsEmergenyPhoneNumber
       
    81 // 
       
    82 // Checks if telephonenumber is an emergency number.
       
    83 // -----------------------------------------------------------------------------
       
    84 //
       
    85 TInt RPhCltEmergencyCall::IsEmergencyPhoneNumber( 
       
    86     const TDesC& aNumber, 
       
    87     TBool& aIsEmergencyNumber )
       
    88     {
       
    89     aIsEmergencyNumber = EFalse;    
       
    90     TPhCltEmergencyNumber emNumber;
       
    91     
       
    92     // Maximum total number size check
       
    93     if ( aNumber.Length() > KPhCltEmergencyNumberSize )
       
    94         {
       
    95         return KErrArgument; 
       
    96         }
       
    97         
       
    98     emNumber.Copy( aNumber );        
       
    99     TBool writeEmergencyNumberBack( EFalse );
       
   100     
       
   101     // Actual check if the number provided is a valid emergency number
       
   102     TInt result = ValidateNumber( emNumber, aIsEmergencyNumber, 
       
   103                                 writeEmergencyNumberBack );    
       
   104 
       
   105     return result;    
       
   106     }
       
   107 
       
   108 // -----------------------------------------------------------------------------
       
   109 // RPhCltEmergencyCall::IsEmergenyPhoneNumber
       
   110 // 
       
   111 // Checks if telephonenumber is an emergency number.
       
   112 // -----------------------------------------------------------------------------
       
   113 //
       
   114 TInt RPhCltEmergencyCall::IsEmergencyPhoneNumber( 
       
   115     const TDesC& aNumber,
       
   116     TDes& aMatchedEmergencyNumber, 
       
   117     TBool& aIsEmergencyNumber )
       
   118     {
       
   119     aIsEmergencyNumber = EFalse;
       
   120     
       
   121     // Maximum total number size check
       
   122     if ( aNumber.Length() > KPhCltEmergencyNumberSize )
       
   123         {
       
   124         return KErrArgument; 
       
   125         }
       
   126         
       
   127     aMatchedEmergencyNumber.Copy( aNumber );   
       
   128     TBool writeEmergencyNumberBack( ETrue );
       
   129 
       
   130     // Actual check if the number provided is a valid emergency number    
       
   131     TInt result = ValidateNumber( aMatchedEmergencyNumber, aIsEmergencyNumber, 
       
   132                                 writeEmergencyNumberBack );
       
   133                                 
       
   134     // Reset the matched number, if no match was found
       
   135     if ( !aIsEmergencyNumber )
       
   136         {
       
   137         aMatchedEmergencyNumber = KNullDesC;
       
   138         }
       
   139                                 
       
   140     return result;    
       
   141     }
       
   142     
       
   143 // -----------------------------------------------------------------------------
       
   144 // RPhCltEmergencyCall::FindEmergencyPhoneNumber
       
   145 // 
       
   146 // Checks if telephonenumber is an emergency number.
       
   147 // Found emergency number returned
       
   148 // -----------------------------------------------------------------------------
       
   149 //
       
   150 TInt RPhCltEmergencyCall::FindEmergencyPhoneNumber( 
       
   151     TDes& aNumber, 
       
   152     TBool& aIsEmergencyNumber )
       
   153     {   
       
   154     TPckg< TBool > pIsEmergencyNumber( aIsEmergencyNumber );
       
   155     
       
   156     if ( aNumber.Length() > KPhCltTelephoneNumberLength )
       
   157         {
       
   158         return KErrArgument;
       
   159         }
       
   160     
       
   161     TPckg< TPhCltTelephoneNumber > pNumber( 
       
   162         static_cast<TPhCltTelephoneNumber&>( aNumber ) );
       
   163             
       
   164     return SendReceive( 
       
   165         EPhoneServerEmergencyNumberSubSessionIsEmergencyNumber, 
       
   166         TIpcArgs( 
       
   167             &pNumber,
       
   168             &pIsEmergencyNumber,
       
   169             EPhCltEmergencyNumberQueryModeAdvanced ) );
       
   170     }
       
   171     
       
   172 // -----------------------------------------------------------------------------
       
   173 // RPhCltEmergencyCall::DialEmergencyCall
       
   174 // 
       
   175 // Sends a dial request to the server.
       
   176 // -----------------------------------------------------------------------------
       
   177 //
       
   178 void RPhCltEmergencyCall::DialEmergencyCall( 
       
   179     TRequestStatus& aReqStatus, 
       
   180     TDesC8& aNumber )
       
   181     {
       
   182     return SendReceive( 
       
   183         EPhoneServerEmergencyNumberSubsessionEmergencyDial,
       
   184         TIpcArgs( &aNumber ),
       
   185         aReqStatus );
       
   186     }
       
   187 
       
   188 // -----------------------------------------------------------------------------
       
   189 // RPhCltEmergencyCall::CancelDialEmergencyCall
       
   190 // 
       
   191 // Cancels an emergency call.
       
   192 // -----------------------------------------------------------------------------
       
   193 //
       
   194 void RPhCltEmergencyCall::CancelDialEmergencyCall()
       
   195     {
       
   196     SendReceive( 
       
   197         EPhoneServerEmergencyNumberSubsessionEmergencyDialCancel,
       
   198         TIpcArgs() );
       
   199     }
       
   200 
       
   201 // -----------------------------------------------------------------------------
       
   202 // Extracts telephone number out of string. Valid emergency number can
       
   203 // have CLIR SS code and DTMF in it.
       
   204 // -----------------------------------------------------------------------------
       
   205 //
       
   206 TBool RPhCltEmergencyCall::ExtractTelephoneNumber( TDes& aString )
       
   207     {    
       
   208     // Emergency number may contain CLIR ss code, so remove
       
   209     // possible CLIR code from the number.
       
   210     RemoveCLIR( aString );
       
   211     
       
   212     // Emergency number may contain DTMF. 
       
   213     RemoveDTMF( aString );
       
   214     
       
   215     if ( aString.Length() )
       
   216         {
       
   217         // First character in emergency can be +, but after that all characters must be digits.
       
   218         const TChar KPlusChar = '+';
       
   219         TChar firstCharacter = aString[0];
       
   220         if ( firstCharacter == KPlusChar )
       
   221             {
       
   222             aString = aString.Right( aString.Length()-1 );
       
   223             }
       
   224         
       
   225         // Number should be only digits.
       
   226         for ( TInt i = 0; i < aString.Length(); i++ )
       
   227             {
       
   228             TChar character = aString[i];
       
   229             if ( !character.IsDigit() )
       
   230                 {
       
   231                 return EFalse;
       
   232                 }
       
   233             }
       
   234         }
       
   235 
       
   236     // This might be a valid emergency number. Final check is
       
   237     // done by EnPolicy.
       
   238     if ( aString.Length() )
       
   239         {
       
   240         return ETrue;
       
   241         }
       
   242     // If string length is zero after parsing, no reason to check it
       
   243     // with EnPolicy, jus return EFalse.
       
   244     else
       
   245         {
       
   246         return EFalse;
       
   247         }
       
   248     
       
   249     }
       
   250     
       
   251 // -----------------------------------------------------------------------------
       
   252 // Finds start of DTMF string. DTMF string starts with p or w character.
       
   253 // -----------------------------------------------------------------------------
       
   254 //
       
   255 TInt RPhCltEmergencyCall::FindStartOfDtmfString( const TDesC& aString )
       
   256     {
       
   257     // If string contains 'p' or 'w' returns true.
       
   258     TInt indexp; //char 'p' index
       
   259     TInt indexw;// char 'w' index
       
   260     TPtrC ptrDtmfCharp( KPhCltDtmfCharp );
       
   261     TPtrC ptrDtmfCharw( KPhCltDtmfCharw );
       
   262 
       
   263     indexp = aString.Locate( ptrDtmfCharp[ 0 ] );
       
   264     indexw = aString.Locate( ptrDtmfCharw[ 0 ] ); 
       
   265 
       
   266     TInt dtmfIndex = KErrNotFound;
       
   267     if ( indexp != KErrNotFound || indexw != KErrNotFound )
       
   268         {
       
   269         // dtmf char found
       
   270         if ( indexw == KErrNotFound )
       
   271             {
       
   272             // char p index
       
   273             dtmfIndex = indexp;    
       
   274             }   
       
   275         else if ( indexp == KErrNotFound )
       
   276             {
       
   277             // char w index
       
   278             dtmfIndex = indexw;    
       
   279             }                 
       
   280         else
       
   281             {
       
   282             // Both chars p and w found, smaller index selected
       
   283             indexp < indexw ? dtmfIndex = indexp : dtmfIndex = indexw;    
       
   284             }         
       
   285         }      
       
   286     
       
   287     return dtmfIndex; 
       
   288     }
       
   289 
       
   290 // -----------------------------------------------------------------------------
       
   291 // Removes CLIR SS code
       
   292 // -----------------------------------------------------------------------------
       
   293 //    
       
   294 void RPhCltEmergencyCall::RemoveCLIR( TDes& aString )
       
   295     {
       
   296     
       
   297     // Check for valid SS codes. Compare returns zero if strings match.
       
   298     if ( !aString.Left( KPhCltMinSsStringLength ).Compare( KPhCltSsCLIRInvoke ) ||
       
   299         !aString.Left( KPhCltMinSsStringLength ).Compare( KPhCltSsCLIRSuppress ) )        
       
   300         {
       
   301         // Extract string after the CLIR ss code.  
       
   302         aString = aString.Right( aString.Length() - KPhCltSsCLIRInvoke().Length() );
       
   303         }
       
   304     }
       
   305 
       
   306 // -----------------------------------------------------------------------------
       
   307 // Removes DTMF from string.
       
   308 // -----------------------------------------------------------------------------
       
   309 // 
       
   310 void RPhCltEmergencyCall::RemoveDTMF( TDes& aString )
       
   311     {
       
   312     const TInt dtmfIndex  = FindStartOfDtmfString( aString );
       
   313     if ( dtmfIndex != KErrNotFound )
       
   314         {               
       
   315         aString = aString.Left( dtmfIndex );
       
   316         }
       
   317     }
       
   318 
       
   319 // -----------------------------------------------------------------------------
       
   320 // RPhCltEmergencyCall::ValidateNumber
       
   321 //
       
   322 // -----------------------------------------------------------------------------
       
   323 //    
       
   324 TInt RPhCltEmergencyCall::ValidateNumber( TDes& aString,
       
   325                                         TBool& aIsEmergencyNumber,
       
   326                                         const TBool aWriteEmergencyNumBack )
       
   327     {
       
   328     TPckg<TBool> pIsEmergencyNumber( aIsEmergencyNumber );
       
   329     
       
   330     // Check and remove additional characters from the phone number
       
   331     TBool isPotentialEmNumber = ExtractTelephoneNumber( aString ); 
       
   332     
       
   333     // Pass the number on to EnPolicy for further check
       
   334     if ( isPotentialEmNumber )
       
   335         {
       
   336         // Maximum length of digit part check
       
   337         if ( aString.Length() > KPhCltMaxEmergencyNumberLength )
       
   338             {
       
   339             return KErrArgument;
       
   340             }
       
   341                    
       
   342         // Use write-back mode if requested            
       
   343         if ( aWriteEmergencyNumBack )
       
   344             {
       
   345             TPckg< TPhCltTelephoneNumber > pNumber( 
       
   346                 static_cast<TPhCltTelephoneNumber&>( aString ) );
       
   347             return SendReceive( 
       
   348                 EPhoneServerEmergencyNumberSubSessionIsEmergencyNumber, 
       
   349                 TIpcArgs( 
       
   350                     &pNumber,
       
   351                     &pIsEmergencyNumber,
       
   352                     EPhCltEmergencyNumberQueryModeNormalWriteback ) );                    
       
   353             }
       
   354         // Else use the normal mode
       
   355         else
       
   356             {
       
   357             TPckgC<TPhCltEmergencyNumber> pNumber( aString ); 
       
   358             return SendReceive( 
       
   359                 EPhoneServerEmergencyNumberSubSessionIsEmergencyNumber, 
       
   360                 TIpcArgs( 
       
   361                     &pNumber,
       
   362                     &pIsEmergencyNumber,
       
   363                     EPhCltEmergencyNumberQueryModeNormal ) );
       
   364             }                     
       
   365         }
       
   366     else
       
   367         {
       
   368         return KErrNone;
       
   369         }
       
   370     }
       
   371     
       
   372 //  End of File
       
   373