phoneengine/callhandling/src/cpesinglecall.cpp
changeset 0 5f000ab63145
child 21 92ab7f8d0eab
equal deleted inserted replaced
-1:000000000000 0:5f000ab63145
       
     1 /*
       
     2 * Copyright (c) 2003-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:  This file contains the implementation of CPESingleCall class 
       
    15 *                member functions.
       
    16 *
       
    17 */
       
    18 
       
    19 
       
    20 // INCLUDE FILES
       
    21 #include <pepanic.pan>
       
    22 #include <talogger.h>
       
    23 
       
    24 #include "cpesinglecall.h"
       
    25 #include "mpecallowner.h"
       
    26 #include "cpevideocallhandling.h"
       
    27 
       
    28 
       
    29 // ================= MEMBER FUNCTIONS =======================
       
    30 // Destructor
       
    31 //
       
    32 CPESingleCall::~CPESingleCall()
       
    33     {
       
    34     TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::~CPESingleCall: Start." );
       
    35     TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::~CPESingleCall: Complete." );
       
    36     }
       
    37 
       
    38 // -----------------------------------------------------------------------------
       
    39 // CPESingleCall::CPESingleCall
       
    40 // C++ default constructor can NOT contain any code, that
       
    41 // might leave.
       
    42 // -----------------------------------------------------------------------------
       
    43 //
       
    44 CPESingleCall::CPESingleCall( 
       
    45         MPEMessageSender& aOwner
       
    46         ) : CPESingleCallObserver( aOwner ),
       
    47 		    iMissedCall( EFalse)
       
    48     {
       
    49     TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::CPESingleCall start." );
       
    50     TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::CPESingleCall complete." );
       
    51     }
       
    52 
       
    53 // -----------------------------------------------------------------------------
       
    54 // CPEGsmVoiceCall::ConstructL
       
    55 // Symbian 2nd phase constructor can leave.
       
    56 // -----------------------------------------------------------------------------
       
    57 //
       
    58 void CPESingleCall::ConstructL()
       
    59     {
       
    60     TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall:::ConstructL start." );
       
    61     TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::ConstructL complete." );
       
    62     }
       
    63 
       
    64 // -----------------------------------------------------------------------------
       
    65 // CPEGsmVoiceCall::NewL
       
    66 // Two-phased constructor.
       
    67 // -----------------------------------------------------------------------------
       
    68 //
       
    69 CPESingleCall* CPESingleCall::NewL( 
       
    70         MPEMessageSender& aOwner )
       
    71     {
       
    72     TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::NewL start." );
       
    73     CPESingleCall* self = new ( ELeave ) CPESingleCall( aOwner );
       
    74     CleanupStack::PushL(self);
       
    75     self->ConstructL( );
       
    76     CleanupStack::Pop( self );
       
    77 
       
    78     TEFLOGSTRING( KTAOBJECT, "CALL CPESingleCall::NewL complete." );
       
    79     return self;
       
    80     }
       
    81 
       
    82 // -----------------------------------------------------------------------------
       
    83 // CPESingleCall::SendMessage
       
    84 // Method reroutes messages from other modules to the CPEPhoneData-object
       
    85 // Note that it does not use base class SendMessage.
       
    86 // -----------------------------------------------------------------------------
       
    87 //
       
    88 void CPESingleCall::SendMessage( 
       
    89         const MEngineMonitor::TPEMessagesFromPhoneEngine aMessage )
       
    90     {
       
    91     iErrorCode = KErrNone;
       
    92     if( aMessage == MEngineMonitor::EPEMessageIdle )
       
    93         {
       
    94         // Get the call duration before the call object is closed.
       
    95         iDuration = Call().CallDuration();
       
    96         TEFLOGSTRING2( 
       
    97             KTAREQEND, 
       
    98             "CALL CPESingleCall::SendMessage: MCCECall::GetCallDuration() called, Duration: %d", 
       
    99             iDuration.Int() );
       
   100         }
       
   101    
       
   102     if ( aMessage != MEngineMonitor::EPEMessageUnknown )
       
   103         {
       
   104         CPECall::SendMessage( aMessage );
       
   105         }
       
   106         
       
   107     }
       
   108 
       
   109 // -----------------------------------------------------------------------------
       
   110 // CPESingleCall::Answer
       
   111 // Method Answers the incoming call.
       
   112 // Method creates iCallInfo parameter package and
       
   113 // makes answer request to CPECallCommand-parameter.
       
   114 // -----------------------------------------------------------------------------
       
   115 //
       
   116 TInt CPESingleCall::Answer()
       
   117     {
       
   118     SetMissedCall( EFalse );
       
   119     return Call().Answer();    
       
   120     }
       
   121 
       
   122 // -----------------------------------------------------------------------------
       
   123 // CPESingleCall::Dial
       
   124 // creates dial request to the CPECallCommand object.
       
   125 // Method opens the line for the new call.
       
   126 // If error occurs the method returns error value.
       
   127 // Method makes call parameter package and
       
   128 // starts monitoring call statuses and call events and
       
   129 // makes a dial request to the CPECallCommand object.
       
   130 // -----------------------------------------------------------------------------
       
   131 //
       
   132 TInt CPESingleCall::Dial( 
       
   133         const RMobileCall::TTelNumberC& aNumber )
       
   134     {
       
   135     TInt errorCode( KErrNone );
       
   136     iDialledNumber = aNumber;
       
   137     
       
   138     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Dial");
       
   139     errorCode = Call().Dial(KNullDesC8);
       
   140     
       
   141     return errorCode;
       
   142     }
       
   143 
       
   144 // -----------------------------------------------------------------------------
       
   145 // CPESingleCall::DialEmergency
       
   146 // creates emergency dial request to the CPECallCommand object
       
   147 // -----------------------------------------------------------------------------
       
   148 //
       
   149 void CPESingleCall::DialEmergency(
       
   150         const TPEPhoneNumber& aEmergencyNumber )
       
   151     {
       
   152     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::DialEmergency" );
       
   153     iCall->DialEmergencyCall( aEmergencyNumber );
       
   154     }
       
   155 
       
   156 // -----------------------------------------------------------------------------
       
   157 // CPESingleCall::DisableFDNCheck
       
   158 // Disables FDN checking for SIM ATK originated calls
       
   159 // -----------------------------------------------------------------------------
       
   160 //
       
   161 void CPESingleCall::DisableFDNCheck()
       
   162     {
       
   163     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::DisableFDNCheck UNSUPPORTED" );
       
   164     
       
   165     // NOTE! Currently disabled due to incomplete TSY implementation
       
   166     // Remove comments after this task is completed
       
   167     
       
   168     //iCall->NoFDNCheck();
       
   169     }
       
   170 		
       
   171 // -----------------------------------------------------------------------------
       
   172 // CPESingleCall::Hold
       
   173 // creates hold request to the CPECallCommand object
       
   174 // -----------------------------------------------------------------------------
       
   175 //
       
   176 TInt CPESingleCall::Hold()
       
   177     {
       
   178     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Hold" );
       
   179     return iCall->Hold();
       
   180     }
       
   181 
       
   182 // -----------------------------------------------------------------------------
       
   183 // CPESingleCall::Resume
       
   184 // Method resumes held call
       
   185 // -----------------------------------------------------------------------------
       
   186 //
       
   187 TInt CPESingleCall::Resume()
       
   188     {
       
   189     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Resume" );
       
   190     return iCall->Resume();
       
   191     }
       
   192 
       
   193 // -----------------------------------------------------------------------------
       
   194 // CPESingleCall::Swap
       
   195 // Method swaps active and held call
       
   196 // -----------------------------------------------------------------------------
       
   197 //
       
   198 TInt CPESingleCall::Swap()
       
   199     {
       
   200     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Swap" );
       
   201     return iCall->Swap();
       
   202     }
       
   203 
       
   204 // -----------------------------------------------------------------------------
       
   205 // CPESingleCall::Transfer
       
   206 // Method Transfers the active and the held call.
       
   207 // -----------------------------------------------------------------------------
       
   208 //
       
   209 void CPESingleCall::Transfer( const TDesC& aTransferTarget )
       
   210     {
       
   211     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Transfer" );
       
   212     iCall->AttendedTransfer( aTransferTarget );
       
   213     }
       
   214 
       
   215 // -----------------------------------------------------------------------------
       
   216 // CPESingleCall::Tone
       
   217 // Returns the inband tone needed to play in state transition
       
   218 // -----------------------------------------------------------------------------
       
   219 //
       
   220 TCCPTone CPESingleCall::Tone()
       
   221     {
       
   222     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::Tone" );
       
   223     return iCall->Tone();
       
   224     }
       
   225 
       
   226 // -----------------------------------------------------------------------------
       
   227 // CPESingleCall::HangUp
       
   228 // 
       
   229 // -----------------------------------------------------------------------------
       
   230 //
       
   231 TInt CPESingleCall::HangUp()
       
   232     {
       
   233     TEFLOGSTRING( KTAREQOUT, "CALL CPESingleCall::HangUp" );
       
   234     SetMissedCall( EFalse );
       
   235     return iCall->HangUp();
       
   236     }
       
   237 
       
   238 // -----------------------------------------------------------------------------
       
   239 // CPESingleCall::GetCallInfo
       
   240 // Method returns call information.
       
   241 // -----------------------------------------------------------------------------
       
   242 //
       
   243 TInt CPESingleCall::GetCallInfo(
       
   244         RMobileCall::TMobileCallInfoV3& aCallInfo )
       
   245     {
       
   246     TEFLOGSTRING( KTAREQOUT, 
       
   247             "CALL CPESingleCall::GetCallInfo > RMobileCall::GetMobileCallInfo()" );
       
   248     RMobileCall::TMobileCallInfoV3Pckg callInfoPckg( iCallInfo );
       
   249     Call().GetMobileCallInfo( callInfoPckg );
       
   250 
       
   251     iCallInfo = callInfoPckg();
       
   252    
       
   253     aCallInfo = iCallInfo;
       
   254     return KErrNone;
       
   255     }
       
   256 
       
   257 // -----------------------------------------------------------------------------
       
   258 // CPESingleCall::SetMissedCall
       
   259 // Set the missed call indicator = ETrue, if the current call
       
   260 // was hanged up on state ringing by remote party.
       
   261 // -----------------------------------------------------------------------------
       
   262 //
       
   263 void CPESingleCall::SetMissedCall( TBool aMissed )
       
   264     {
       
   265     TEFLOGSTRING2( KTAINT, "CALL CPESingleCall::SetMissedCall: Call Missed. %d", aMissed );
       
   266     iMissedCall = aMissed; 
       
   267     }
       
   268 
       
   269 // -----------------------------------------------------------------------------
       
   270 // CPESingleCall::GetMissedCall
       
   271 // Returns the missed data call indicator.
       
   272 // -----------------------------------------------------------------------------
       
   273 //
       
   274 TInt CPESingleCall::GetMissedCall(
       
   275         TBool& aMissedCall) const
       
   276     {
       
   277     aMissedCall = iMissedCall;
       
   278     return KErrNone;
       
   279     }
       
   280 
       
   281 // -----------------------------------------------------------------------------
       
   282 // CPESingleCall::IsSecureCall
       
   283 // -----------------------------------------------------------------------------
       
   284 //
       
   285 TBool CPESingleCall::IsSecureCall() const
       
   286     {
       
   287     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::IsSecureCall" );
       
   288     return iCall->IsSecured();
       
   289     }
       
   290 
       
   291 // -----------------------------------------------------------------------------
       
   292 // CPESingleCall::SecureSpecified
       
   293 // -----------------------------------------------------------------------------
       
   294 //
       
   295 TBool CPESingleCall::SecureSpecified() const
       
   296     {
       
   297     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::SecureSpecified" );
       
   298     return iCall->SecureSpecified(); 
       
   299     }
       
   300 
       
   301 // -----------------------------------------------------------------------------
       
   302 // CPESingleCall::AcceptUnattendedTransfer
       
   303 // -----------------------------------------------------------------------------
       
   304 //
       
   305 TInt CPESingleCall::AcceptUnattendedTransfer()
       
   306     {
       
   307     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::AcceptUnattendedTransfer" );
       
   308     
       
   309     return iCall->AcceptTransfer( ETrue );
       
   310     }
       
   311 
       
   312 
       
   313 // -----------------------------------------------------------------------------
       
   314 // CPESingleCall::RejectUnattendedTransfer
       
   315 // -----------------------------------------------------------------------------
       
   316 //
       
   317 TInt CPESingleCall::RejectUnattendedTransfer()
       
   318     {
       
   319     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::RejectUnattendedTransfer" );
       
   320     
       
   321     return iCall->AcceptTransfer( EFalse );
       
   322     }
       
   323 
       
   324 // -----------------------------------------------------------------------------
       
   325 // CPESingleCall::UnattendedTransfer
       
   326 // -----------------------------------------------------------------------------
       
   327 //
       
   328 TInt CPESingleCall::UnattendedTransfer( const TDesC& aTransferTo ) const
       
   329     {
       
   330     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::UnattendedTransfer" );
       
   331 
       
   332     return iCall->UnattendedTransfer( aTransferTo );
       
   333     }
       
   334 
       
   335 // -----------------------------------------------------------------------------
       
   336 // CPESingleCall::ForwardCallToAddress
       
   337 // -----------------------------------------------------------------------------
       
   338 //
       
   339 TInt CPESingleCall::ForwardCallToAddress( TInt aIndex )
       
   340     {
       
   341     TEFLOGSTRING( KTAINT, "CALL CPESingleCall::ForwardToAddress" );
       
   342     TRAPD( err, iCall->ForwardToAddressL( aIndex ) );
       
   343     return err;
       
   344     }
       
   345     
       
   346 // End of File