/*
* 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:  Header of CSPTransferProvider which provides methods and
*                functionality to handle call transfering
*
*/


#ifndef CSPTRANSFERPROVIDER_H
#define CSPTRANSFERPROVIDER_H

#include <e32base.h>
#include <mccptransferprovider.h>
#include <mccptransferobserver.h>

class RMobileCall;
class MCSPCallErrorObserver;
class MCSPCommonInfo;

/**
* Call transfer methods.
* MCCPCallObserver is used for errors, statuses, notifications etc
*
*  @since S60 3.2
*/
class CSPTransferProvider : public CActive,
                            public MCCPTransferProvider
    {
    
    public:
        /**
        * Two phased constructing of the transfer provider instance.
        * @param aCall mobile call handle
        * @return the Transfer provider instance
        */
        static CSPTransferProvider* NewL( RMobileCall& aCall, 
                MCSPCallErrorObserver& aErrorObserver,
                MCSPCommonInfo& aCommonInfo );        

        /** 
        * Destructs the transfer provider.
        * @since S60 3.2
        */
        virtual ~CSPTransferProvider();
        
    public:

    // from base class MCCPTransferProvider
        /**
        * Attended transfer to given call recipient.
        * There exist a call between A-B and A-C. A wants to transfer the call
        * to B-C. A itself will not be inline in case the transfer is made 
        * succesfully.In above case C will be the aTransferTargetCall. B is 
        * the recipient of the current call between A-B - called on A's call
        * object transfer provider. The A-B call is on hold (optional).
        *
        * @param aTransferTargetCall Target receiver of the transferred call. 
        *                            In this case there exist a call.
        * @return In case of an immediate error returns system error code, 
        *         if request has been started returns KErrNone.
        * Actual request result indication comes via observer class
        */
        TInt AttendedTransfer( MCCPCall& aTransferTargetCall );

        /**
        * Attended transfer to given address. There does not need to be 
        * a current call between the given transfer target.
        * @param aTransferTarget Transfer target address
        * @return In case of an immediate error returns system error code,
        *         if request has been started returns KErrNone.
        * Actual request result indication comes via observer class
        */
        TInt AttendedTransfer( const TDesC& aTransferTarget );

        /**
        * Unattended transfer. Call is requested to be transferred to given
        * address. After ECCPRemoteTransferring event current call will be
        * disconnected and no transfer status is checked from the operation. 
        * @param aTransferTarget Address of the target
        * @return In case of an immediate error returns system error code, 
        *         if request has been started returns KErrNone.
        * Actual request result indication comes via observer class
        */
        TInt UnattendedTransfer( const TDesC& aTransferTarget );

        /**
        * Accept incoming call transfer request from the call remote party.
        * @param aAccept ETrue - accept transfer, 
        *                EFalse do not accept transfer request.
        * @return In case of an immediate error returns system error code, 
        *         if request has been started returns KErrNone.
        * Actual request result indication comes via observer class
        */
        TInt AcceptTransfer( const TBool aAccept );
          
        /**
        * When the other end of the call has requested call transfer to
        * third party it is notified to 
        * CCPCallCall::EventOccurred(ECCPRemoteTransferring).
        * The new recipient of the call can be fetched via this method.
        * @return New recipient for the call after transfer
        */
        const TDesC& TransferTarget() const;
        
        /**
        * Add an observer for transfer related events.
        * Plug-in dependent feature if duplicates or more than one observers 
        * are allowed or not. Currently CCE will set only one observer.
        * @since S60 v3.2
        * @param aObserver Observer
        * @leave system error if observer adding fails
        */
        void AddObserverL( const MCCPTransferObserver& aObserver );

        /**
        * Remove an observer.
        * @since S60 v3.2
        * @param aObserver Observer
        * @return KErrNone if removed succesfully
        *         KErrNotFound if observer was not found.
        *         Any other system error depending on the error.
        */
        TInt RemoveObserver( const MCCPTransferObserver& aObserver );
        
        /**
        * A transfer event has occurred concerning a specific call.
        * @since S60 3.2
        * @param aEvent Occurred event.
        */
        void TransferEventOccurred( 
            const MCCPTransferObserver::TCCPTransferEvent aEvent );

    // from base class CActive
    protected:
            /**
        * From CActive
        * RunL
        * @since S60 3.2
        */
        void RunL();
            
        /**
        * From CActive
        * Cancels the monitor
        * @since S60 3.2
        */
        void DoCancel();  

    private:
        /**
        * Constructs the provider
        *
        * @param aCall handle mobile call
        */
        CSPTransferProvider( RMobileCall& aCall, 
                             MCSPCallErrorObserver& aErrorObserver,
                             MCSPCommonInfo& aCommonInfo );

        /**
        * Constructing 2nd phase.
        */
        void ConstructL();
        
    private: // data

        /**
        * DTMF event observer.
        */
        RPointerArray<MCCPTransferObserver> iObservers;
            
        /**
        * Etel call object
        */
        RMobileCall& iCall;
        
        /**
        * Error observer;
        */
        MCSPCallErrorObserver& iErrorObserver;
        
        /**
        * Common information for calls.
        */
        MCSPCommonInfo& iCommonInfo;


};

#endif CSPTRANSFERPROVIDER_H