/*
* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Contains transfer handling logic
*
*/

#include "cccelogger.h"
#include "cccetransfercontroller.h"
#include "cccecallcontainer.h"
#include "cccecall.h"
#include "mccpcall.h"
#include "mccpcscall.h"
#include "mccecallobserver.h"

// ======== MEMBER FUNCTIONS ========


// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CCCETransferController::CCCETransferController( 
    CCCECallContainer& aCallContainer ) :
    iCallContainer( aCallContainer )
    {
    Reset();
    }

// ---------------------------------------------------------------------------
// CCCETransferController::NewL
// ---------------------------------------------------------------------------
//
CCCETransferController* CCCETransferController::NewL( 
    CCCECallContainer& aCallContainer )
    {
    CCCETransferController* self = new( ELeave ) CCCETransferController(
        aCallContainer );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CCCETransferController::~CCCETransferController()
    {
    Reset();
    }

// ---------------------------------------------------------------------------
// CCCETransferController::ErrorOccurred
// ---------------------------------------------------------------------------
//
void CCCETransferController::ErrorOccurred( 
    const TCCPError aError, MCCPCall* /*aCall*/ ) 
    {
    CCELOGSTRING2("CCCETransferController::ErrorOccurred() aError=%d", aError);    
    (void) aError; // remove urel compile warning 
    }
        
// ---------------------------------------------------------------------------
// CCCETransferController::CallStateChanged
// ---------------------------------------------------------------------------
//   
void CCCETransferController::CallStateChanged( 
    const MCCPCallObserver::TCCPCallState aState, MCCPCall* /*aCall*/ ) 
    {
    CCELOGSTRING2("CCCETransferController::CallStateChanged():IN \
            aState=%d", aState);
    
    switch ( aState )
        {
        case ECCPStateIdle:
            {
            CCELOGSTRING("CCCETransferController::CallStateChanged: ECCPStateIdle");
            if ( iOriginatorCall && iObservedCall == iOriginatorCall )
                {
                CCELOGSTRING("CCCETransferController::CallStateChanged: Idle -> release original call");
                iCallContainer.ReleaseCall( *iOriginatorCall, iOriginatorCall->Uid() ); 
                iOriginatorCall = NULL;
                iObservedCall = NULL;
                }
            else if ( iTransferCall && iObservedCall == iTransferCall )
                {
                CCELOGSTRING("CCCETransferController::CallStateChanged: Idle -> release transfer call");
                iCallContainer.ReleaseCall( *iTransferCall, iTransferCall->Uid() ); 
                iTransferCall = NULL;
                iObservedCall = NULL;
                }
            }
            break;  
        case ECCPStateConnected:
            {
            CCELOGSTRING("CCCETransferController::CallStateChanged: ECCPStateConnected ");
            CCCECall* originator = iCallContainer.GetCall( iOriginatorCall );
            
            if ( !originator ||
                 ( originator->State() != CCPCall::EStateHold &&
                 originator->State() != CCPCall::EStateConnected ) )
                {
                // Originator disconnected or released.
                // Terminate transfer call.
                TInt err = iTransferCall->HangUp();
                if ( err )
                    {
                    ReleaseTransferCall();
                    }
                
                }
            else if (  ECCETypeAttendedMO == iOngoingTransferType )
                {
                // Transfer call was connected
                // Swap transfer call with original call and hangup&release
                // original call
                
                
                TRAPD( err, 
                       originator->SetConvergedCallL( iTransferCall, 
                           iTransferCall->Uid(), ETrue );
                       iTransferCall->RemoveObserver( *this );
                       iTransferCall->AddObserverL( *originator ); 
                       iOriginatorCall->RemoveObserver( *originator );
                       iOriginatorCall->AddObserverL( *this ); );

                
    
                iObservedCall = iOriginatorCall;
                
                if ( KErrNone == err )
                    {
                    // If original call was on hold, new call must be on hold also
                    if ( ECCPStateHold == originator->State() )
                        {
                        iTransferCall->Hold();
                        }
                   
                    // New call is no more on hold by remote end
                    static_cast<MCCPCallObserver*>(originator)->CallEventOccurred( ECCPRemoteResume, 
                                                                &originator->GetCCPCall() ); 
                    }
                else
                    {
                    CCELOGSTRING2("CCCETransferController::CallStateChanged():transfer error=%d",
                        err);
                    }
                }
            else if ( ECCETypeAttendedMT == iOngoingTransferType ) 
                {
                
                // Set new transferred call to original CCECall object
                TRAP_IGNORE( originator->SetConvergedCallL( iTransferCall, 
                    iTransferCall->Uid(), ETrue ) );
                
                
                // Release original call 
                iOriginatorCall->RemoveObserver( *originator );
                TRAP_IGNORE( iOriginatorCall->AddObserverL( *this ) );
                
                iObservedCall = iOriginatorCall;
                iOriginatorCall->HangUp();
                }
            }
            break;     
        default:
            CCELOGSTRING2("CCCETransferController::CallStateChanged: \
                    Unhandled state = %d",aState );
            break;
        }
    CCELOGSTRING("CCCETransferController::CallStateChanged():OUT");
    }

// ---------------------------------------------------------------------------
// CallStateChangedWithInband( TCCPCallState aState )
// ---------------------------------------------------------------------------
//
void CCCETransferController::CallStateChangedWithInband( TCCPCallState aState, 
                                                         MCCPCall* aCall ) 
    {
    CCELOGSTRING("CCCETransferController::CallStateChangedWithInband()");
    CallStateChanged( aState, aCall );    
    }

// ---------------------------------------------------------------------------
// CCCETransferController::CallEventOccurred
// ---------------------------------------------------------------------------
// 
void CCCETransferController::CallEventOccurred( 
    const MCCPCallObserver::TCCPCallEvent /*aEvent*/, MCCPCall* /*aCall*/ )
    {
    CCELOGSTRING("CCCETransferController::CallEventOccurred()");
    }

// ---------------------------------------------------------------------------
// CCCETransferController::CallCapsChanged
// ---------------------------------------------------------------------------
// 
void CCCETransferController::CallCapsChanged( const TUint32 /*aCapsFlags*/, 
                                              MCCPCall* /*aCall*/ ) 
    {
    CCELOGSTRING("CCCETransferController::CallCapsChanged():");
    }
    
// ---------------------------------------------------------------------------
// CCCETransferController::Reset
// ---------------------------------------------------------------------------
//
void CCCETransferController::Reset()
    {
    CCELOGSTRING("CCCETransferController::Reset()");
    iOriginatorCall = NULL;
    iOriginatorCallId = KErrNotFound;
    iTransferDialPending = EFalse;
    iTransferAccepted = EFalse;
    iOngoingTransferType = ECCETypeNone;
    iObservedCall = NULL;    
    }
    
// ---------------------------------------------------------------------------
// CCCETransferController::HandleRemoteTransferRequest
// ---------------------------------------------------------------------------
//
void CCCETransferController::HandleRemoteTransferRequest( 
    MCCPCall* aNewTransferCall,
    MCCPCall* aOriginator, 
    TBool aAttented )                            
    {
    CCELOGSTRING("CCCETransferController::HandleTransferRequest():IN");
    
    CCCECall* originator = iCallContainer.GetCall( aOriginator );
    if ( originator && 
        ( originator->State() == CCPCall::EStateHold ||
          originator->State() == CCPCall::EStateConnected ) )
        {
        iOriginatorCall = aOriginator;
        iTransferCall = aNewTransferCall;
        
        // Unattended case
        if ( !aAttented )
            {        
            CCELOGSTRING("CCCETransferController::HandleTransferRequest() unattended ");
            iOriginatorCallId = originator->CallId();       
            iOngoingTransferType = ECCETypeUnattended;     
            originator->HandleTransfer( aAttented, *this );
            }
        // Attended case
        else
            {
            CCELOGSTRING("CCCETransferController::HandleTransferRequest() attended ");
            originator->SetTransferController( this );
            iOngoingTransferType = ECCETypeAttendedMO; 
            TRAP_IGNORE( iTransferCall->AddObserverL( *this ) );
            
            iObservedCall = iTransferCall;
            TInt error = iTransferCall->Dial(); 
            
            if( error )
                {
                CCELOGSTRING2("CCCETransferController: \
                    dial error: %d", error);
                ReleaseTransferCall();    
                }
            }
        }
    else
        {
        CCELOGSTRING("CCCETransferController: Originator call not found!");
        iCallContainer.ReleaseCall( *aNewTransferCall );
        }
    
    CCELOGSTRING("CCCETransferController::HandleTransferRequest():OUT");
    }

// ---------------------------------------------------------------------------
// CCCETransferController::TransferCallIncoming
// ---------------------------------------------------------------------------
//
void CCCETransferController::TransferCallIncoming( MCCPCall* aNewTransferCall,
    MCCPCall* aOriginator )
    {
    CCELOGSTRING("CCCETransferController::TransferCallIncoming():IN");
    iTransferCall = aNewTransferCall;
    iOriginatorCall = aOriginator;
    
    CCCECall* originator = iCallContainer.GetCall( aOriginator );
    if ( originator )
        {
        originator->SetTransferController( this );
        
        iOngoingTransferType = ECCETypeAttendedMT;
         
        TInt err = KErrNone;
        TRAP( err, iTransferCall->AddObserverL( *this ) );
        if ( KErrNone == err )
            {
            iObservedCall = iTransferCall;
            // Answer new call when this gets connected original call will be terminated
            TInt err = iTransferCall->Answer(); 
            
            if ( KErrNone != err )
                {
                CCELOGSTRING2("CCCETransferController::TransferCallIncoming() Answering failed err=%d", err);
                ReleaseTransferCall();
                }
            }
        }
    else
        {
        CCELOGSTRING("CCCETransferController::TransferCallIncoming() originator not \
                found");
        ReleaseTransferCall();
        }
     
    CCELOGSTRING("CCCETransferController::TransferCallIncoming():OUT");
    }
    
// ---------------------------------------------------------------------------
// CCCETransferController::ReleaseTransferCall
// ---------------------------------------------------------------------------
//
 void CCCETransferController::ReleaseTransferCall()
    {
    CCELOGSTRING("CCCETransferController::ReleaseTransferCall()");
    if ( iTransferCall )
        {
        iCallContainer.ReleaseCall(*iTransferCall);
        iTransferCall = NULL;
        Reset();
        CCELOGSTRING("CCCETransferController: TransferCall queued \
         to be released");
        }
    }
    
// ---------------------------------------------------------------------------
// CCCETransferController::OngoingTransferType
// ---------------------------------------------------------------------------
// 
CCCETransferController::TTransferType CCCETransferController::OngoingTransferType() const
    {
    return iOngoingTransferType;    
    }
    
// ---------------------------------------------------------------------------
// CCCETransferController::TransferCall
// ---------------------------------------------------------------------------
// 
MCCPCall* CCCETransferController::TransferCall() const
    {
    return iTransferCall;
    }

// ---------------------------------------------------------------------------
// CCCETransferController::OriginatorCall
// ---------------------------------------------------------------------------
// 
MCCPCall* CCCETransferController::OriginatorCall() const
    {
    return iOriginatorCall;
    }
    
// ---------------------------------------------------------------------------
// CCCETransferController::SetTransferAccepted
// ---------------------------------------------------------------------------
//    
void CCCETransferController::SetTransferAccepted( TBool aAccepted )
    {
    iTransferAccepted = aAccepted;
    }

// ---------------------------------------------------------------------------
// CCCETransferController::TransferAccepted
// ---------------------------------------------------------------------------
//      
TBool CCCETransferController::TransferAccepted() const
    {
    return iTransferAccepted;
    }
    
// ---------------------------------------------------------------------------
// CCCETransferController::SetTransferDialPending
// ---------------------------------------------------------------------------
// 
void CCCETransferController::SetTransferDialPending( TBool aDialPending )
    {
    CCELOGSTRING3("CCCETransferController::SetTransferDialPending() \
    iDialPending=%d aDialPending=%d",iTransferDialPending, aDialPending);
    iTransferDialPending = aDialPending;
    }
    
// ---------------------------------------------------------------------------
// CCCETransferController::HandleCallStateChanged
// ---------------------------------------------------------------------------
// 
void CCCETransferController::HandleCallStateChanged( CCCECall* aCall,
        CCPCall::TCallState aStatus )
    {
    CCELOGSTRING2("CCCETransferController::HandleCallStatusChange():IN aStatus=%d",
            aStatus);
    
    switch ( aStatus )
        {         
        case CCPCall::EStateIdle:
        // flow through
        case CCPCall::EStateConnected:  
            {
            // When original or new call goes to idle/connected transfercontroller
            // can be resetted
            if( &aCall->GetCCPCall() == iOriginatorCall || 
                &aCall->GetCCPCall() == iTransferCall )
                {
                Reset();
                }
            }
            break;        
        case CCPCall::EStateDisconnecting:
            {
            // When original call goes to disconnecting state and there
            // is unattended transfer dial pending. Start dialing.
            if ( &aCall->GetCCPCall() == iOriginatorCall &&
                iTransferDialPending )
                {
                CCCECall* call =iCallContainer.GetCall( iTransferCall );
                if ( call )
                    {
                    iTransferDialPending = EFalse;
                    call->DoPendingRequest();
                    }
                }
            }
            break;  
        default:
            CCELOGSTRING2("CCCETransferController::HandleCallStatusChange: \
                    Unhandled state = %d", aStatus );
        }
    CCELOGSTRING("CCCETransferController::HandleCallStatusChange():OUT");
    }
// End of file