vtengines/videoteleng/CallCtrl/Src/CVtCtlCallStatusMonitor.cpp
changeset 0 ed9695c8bcbe
equal deleted inserted replaced
-1:000000000000 0:ed9695c8bcbe
       
     1 /*
       
     2 * Copyright (c) 2007 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:  Monitors call status.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #pragma CTC SKIP
       
    20 // INCLUDE FILES
       
    21 #include    "CVtCtlCallStatusMonitor.h"
       
    22 #include    "MVtCtlCallStatusObserver.h"
       
    23 #include    "VtCtlDefs.h"
       
    24 #include    <cvtlogger.h>
       
    25 
       
    26 // ============================ MEMBER FUNCTIONS ===============================
       
    27 
       
    28 // -----------------------------------------------------------------------------
       
    29 // CVtCtlCallStatusMonitor::CVtCtlCallStatusMonitor
       
    30 // C++ constructor 
       
    31 // -----------------------------------------------------------------------------
       
    32 //
       
    33 /*****************************************************
       
    34 *   Series 60 Customer / ETel
       
    35 *   Series 60  ETel API
       
    36 *****************************************************/
       
    37 CVtCtlCallStatusMonitor::CVtCtlCallStatusMonitor(
       
    38     RMobileCall& aCall,
       
    39     MVtCtlCallStatusObserver& aObserver ) : 
       
    40     CActive( KVtCtlCallStatusMonitorPriority ),
       
    41     iCall( aCall ),
       
    42     iObserver( aObserver ),
       
    43     iCallStatus( RMobileCall::EStatusUnknown ),
       
    44     iPreviousStatus( RMobileCall::EStatusUnknown )
       
    45     {
       
    46     __VTPRINTENTER( "CVtCtlCallStatusMonitor.CVtCtlCallStatusMonitor" )
       
    47     CActiveScheduler::Add( this );
       
    48     __VTPRINTEXIT( "CVtCtlCallStatusMonitor.CVtCtlCallStatusMonitor" )
       
    49     }
       
    50 
       
    51 // -----------------------------------------------------------------------------
       
    52 // CVtCtlCallStatusMonitor::~CVtCtlCallStatusMonitor
       
    53 // destructor
       
    54 // -----------------------------------------------------------------------------
       
    55 //
       
    56 CVtCtlCallStatusMonitor::~CVtCtlCallStatusMonitor()
       
    57     {
       
    58     __VTPRINTENTER( "CVtCtlCallStatusMonitor.~" )
       
    59     Cancel();    
       
    60     __VTPRINTEXIT( "CVtCtlCallStatusMonitor.~" )
       
    61     }
       
    62 
       
    63 
       
    64 // -----------------------------------------------------------------------------
       
    65 // CVtCtlCallStatusMonitor::Start
       
    66 // Starts monitoring
       
    67 // -----------------------------------------------------------------------------
       
    68 //
       
    69 /*****************************************************
       
    70 *   Series 60 Customer / ETel
       
    71 *   Series 60  ETel API
       
    72 *****************************************************/
       
    73 void CVtCtlCallStatusMonitor::Start()
       
    74     {
       
    75     __VTPRINTENTER( "CVtCtlCallStatusMonitor.Start" )
       
    76     if ( iPreviousStatus == RMobileCall::EStatusUnknown )
       
    77         {
       
    78         RMobileCall::TMobileCallStatus status( RMobileCall::EStatusUnknown );
       
    79         if ( iCall.GetMobileCallStatus( status ) == KErrNone )
       
    80             {
       
    81             iPreviousStatus = status;
       
    82             }
       
    83         }
       
    84     if ( !IsActive() )
       
    85         {
       
    86         iCall.NotifyMobileCallStatusChange( iStatus, iCallStatus );
       
    87         SetActive();
       
    88         }
       
    89     __VTPRINTEXIT( "CVtCtlCallStatusMonitor.Start" )
       
    90     }
       
    91 
       
    92 // -----------------------------------------------------------------------------
       
    93 // CVtCtlCallStatusMonitor::DoCancel
       
    94 // Cancels monitoring
       
    95 // -----------------------------------------------------------------------------
       
    96 //
       
    97 void CVtCtlCallStatusMonitor::DoCancel()
       
    98     {
       
    99     __VTPRINTENTER( "CVtCtlCallStatusMonitor.DoCancel" )
       
   100     iCall.CancelAsyncRequest( EMobileCallNotifyMobileCallStatusChange );
       
   101     __VTPRINTEXIT( "CVtCtlCallStatusMonitor.DoCancel" )
       
   102     }
       
   103 
       
   104 // -----------------------------------------------------------------------------
       
   105 // CVtCtlCallStatusMonitor::RunL
       
   106 // Receives call status change and notifies observer
       
   107 // -----------------------------------------------------------------------------
       
   108 //
       
   109 /*****************************************************
       
   110 *   Series 60 Customer / ETel
       
   111 *   Series 60  ETel API
       
   112 *****************************************************/
       
   113 void CVtCtlCallStatusMonitor::RunL()
       
   114     {
       
   115     __VTPRINTENTER( "CVtCtlCallStatusMonitor.RunL" )
       
   116     __VTPRINT2( DEBUG_SESSION , "CallStatMon.RunL err=%d",iStatus.Int() )
       
   117     __VTPRINT2( DEBUG_SESSION , "CallStatMon.RunL sta=%d",
       
   118         (TInt)iCallStatus )
       
   119     if ( iStatus == KErrNone )
       
   120         {
       
   121         const RMobileCall::TMobileCallStatus cache( iCallStatus );
       
   122         Start();
       
   123         MVtCtlCallControl::TVtCtlState state = MapState( cache );
       
   124         if ( CVtCtlCallStatusMonitor::IsLegalNewState( 
       
   125                 cache, iPreviousStatus ) )
       
   126             {
       
   127             iPreviousStatus = cache;
       
   128             if ( state != MVtCtlCallControl::EUnknown )
       
   129                 {
       
   130                 iObserver.HandleCallStatusChangeL( 
       
   131                     KNullSessionId, // unknown by this
       
   132                     state,
       
   133                     MapState( iPreviousStatus ) );
       
   134                 }
       
   135             }
       
   136         }
       
   137     __VTPRINTEXIT( "CVtCtlCallStatusMonitor.RunL" )
       
   138     }
       
   139 
       
   140 // -----------------------------------------------------------------------------
       
   141 // CVtCtlCallStatusMonitor::RunError
       
   142 // 
       
   143 // -----------------------------------------------------------------------------
       
   144 //
       
   145 TInt CVtCtlCallStatusMonitor::RunError(
       
   146 #ifdef VTDEBUG                                       
       
   147     TInt aError )
       
   148 #else
       
   149     TInt /*aError*/ )
       
   150 #endif
       
   151     {
       
   152     __VTPRINTENTER( "CVtCtlCallStatusMonitor.RunError" )
       
   153     __VTPRINTEXITR( "CVtCtlCallStatusMonitor.RunError err=%d", aError )
       
   154     return KErrNone;
       
   155     }
       
   156 
       
   157 // -----------------------------------------------------------------------------
       
   158 // CVtCtlCallStatusMonitor::MapState
       
   159 // Maps Etel call status to internal type
       
   160 // -----------------------------------------------------------------------------
       
   161 //
       
   162 /*****************************************************
       
   163 *   Series 60 Customer / ETel
       
   164 *   Series 60  ETel API
       
   165 *****************************************************/
       
   166 MVtCtlCallControl::TVtCtlState CVtCtlCallStatusMonitor::MapState(
       
   167     const RMobileCall::TMobileCallStatus aStatus )
       
   168     {
       
   169     __VTPRINTENTER( "CVtCtlCallStatusMonitor.MapState" )
       
   170     MVtCtlCallControl::TVtCtlState state( MVtCtlCallControl::EUnknown );
       
   171     switch ( aStatus )
       
   172         {
       
   173         case RMobileCall::EStatusIdle:
       
   174             state = MVtCtlCallControl::EIdle;
       
   175             break;
       
   176         case RMobileCall::EStatusDialling:
       
   177             state = MVtCtlCallControl::EInitializing;
       
   178             break;
       
   179         case RMobileCall::EStatusRinging:
       
   180             state = MVtCtlCallControl::ERinging;
       
   181             break;
       
   182         case RMobileCall::EStatusAnswering:
       
   183             state = MVtCtlCallControl::ERinging;
       
   184             break;
       
   185         case RMobileCall::EStatusConnecting:
       
   186             state = MVtCtlCallControl::EInitializing;
       
   187             break;
       
   188         case RMobileCall::EStatusConnected:
       
   189             state = MVtCtlCallControl::EConnected;
       
   190             break;
       
   191         case RMobileCall::EStatusDisconnecting:
       
   192         case RMobileCall::EStatusDisconnectingWithInband:
       
   193             state = MVtCtlCallControl::EDisconnecting;
       
   194             break;
       
   195         case RMobileCall::EStatusUnknown:
       
   196             state = MVtCtlCallControl::EUnknown;
       
   197             break;
       
   198         default:
       
   199             break;
       
   200         }
       
   201     __VTPRINTEXIT( "CVtCtlCallStatusMonitor.MapState state" )
       
   202     return state;
       
   203     }
       
   204 
       
   205 // -----------------------------------------------------------------------------
       
   206 // CVtCtlCallStatusMonitor::IsLegalNewState
       
   207 // Checks if call state transition specified by arguments is legal.
       
   208 // -----------------------------------------------------------------------------
       
   209 //
       
   210 TBool CVtCtlCallStatusMonitor::IsLegalNewState(
       
   211     const RMobileCall::TMobileCallStatus aNewState,
       
   212     const RMobileCall::TMobileCallStatus aCurrentState )
       
   213     {
       
   214     // check state transition priority          
       
   215     const TInt newPrio = KVtCtlStatusTransitionPriorities[ aNewState ];
       
   216     const TInt prevPrio = KVtCtlStatusTransitionPriorities[ aCurrentState ];
       
   217 
       
   218     /**
       
   219     * Legal transition if new state is logically consecutive compared to old
       
   220     * state. Exception: transition to idle always possible ( !newPrio )
       
   221     */
       
   222     const TBool isLegal = ( newPrio > prevPrio || !newPrio );
       
   223     return isLegal;
       
   224     }
       
   225 #pragma CTC ENDSKIP    
       
   226 //  End of File  
       
   227