/*
* Copyright (c) 2007 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:  Implementation of class CSPEtelCallEventMonitor which
*                monitors call events from ETel and notifies observer
*                accordingly.
*
*/


#include <mccptransferobserver.h>
#include <mccpforwardobserver.h>
#include <mccpconferencecallobserver.h>

#include "cspetelcalleventmonitor.h"
#include "csplogger.h"
#include "cspcall.h"



// ---------------------------------------------------------------------------
// CSPEtelCallEventMonitor::NewL.
// ---------------------------------------------------------------------------
//
CSPEtelCallEventMonitor* CSPEtelCallEventMonitor::NewL( MCSPCallObserver& aObserver,
                                                        RMobileCall& aCall ) 
    {
    CSPLOGSTRING(CSPOBJECT, 
        "CSPEtelCallEventMonitor::NewL()" );
    CSPEtelCallEventMonitor* self = new ( ELeave ) CSPEtelCallEventMonitor( 
                                        aObserver, aCall );
    return self;    
    }

// ---------------------------------------------------------------------------
// Destructs the object by canceling first ongoing monitoring.
// ---------------------------------------------------------------------------
//
CSPEtelCallEventMonitor::~CSPEtelCallEventMonitor( )
    {
    CSPLOGSTRING(CSPOBJECT, 
        "CSPEtelCallEventMonitor::~CSPEtelCallEventMonitor()" );
    Cancel();
    
    if ( iDestrPtr )
        {
        *iDestrPtr = ETrue;
        iDestrPtr = NULL;
        }
    }

// ---------------------------------------------------------------------------
// Starts the monitoring.
// ---------------------------------------------------------------------------
//
void CSPEtelCallEventMonitor::StartMonitoring()
    {
    CSPLOGSTRING( CSPINT, "CSPEtelCallEventMonitor::StartMonitoring" );
    
    if ( !IsActive() )
        {
        CSPLOGSTRING( CSPREQOUT, 
            "CSP: CSPEtelCallEventMonitor::StartMonitoring: \
                    Request RMobilePhone::NotifyCallEvent" );
        iCall.NotifyCallEvent( iStatus, iCallEvent );
        SetActive();
        }
    else
        {
        CSPLOGSTRING( CSPERROR, 
            "CSP: CSPEtelCallEventMonitor::StartMonitoring: Already active" );
        }
    }

// ---------------------------------------------------------------------------
// From CActive
// Handles event notifying.
// ---------------------------------------------------------------------------
//
void CSPEtelCallEventMonitor::RunL()
    {
    CSPLOGSTRING( CSPINT, "CSPEtelCallEventMonitor::RunL")
    
    // Survive from monitor destruction during observing sequence
    TBool destroyed = EFalse;
    iDestrPtr = &destroyed;
    
    if ( iStatus == KErrNone )
        {
        switch ( iCallEvent )
            {
            // The call has been terminated by the remote party. 
            case RMobileCall::ERemoteTerminated:
                {
                CSPLOGSTRING( CSPINT, 
                   "CSP CSPEtelCallEventMonitor::RunL: Remotely terminated" );
                iObserver.NotifyCallEventOccurred( 
                        MCCPCallObserver::ECCPRemoteTerminated );
                break;
                }
             // The call has been placed on hold as a result of a local action
            case RMobileCall::ELocalHold:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Locally held" );
                iObserver.NotifyCallEventOccurred( 
                        MCCPCallObserver::ECCPLocalHold );
                break;
                }
                
            // The call has been resumed as a result of a local action. 
            case RMobileCall::ELocalResume:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Locally resumed" );
                iObserver.NotifyCallEventOccurred( 
                        MCCPCallObserver::ECCPLocalResume );
                break;
                }
            // The call has been deflected to another remote party as a result
            // of a local action.
            case RMobileCall::ELocalDeflectCall:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Locally deflected" );
                iObserver.NotifyTransferCallEventOccurred(  
                        MCCPTransferObserver::ECCPLocalTransfer );
                break;
                }
            // The call has been transferred to another remote party as a 
            // result of a local action. 
            case RMobileCall::ELocalTransfer:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Locally transfered" );
                iObserver.NotifyTransferCallEventOccurred( 
                        MCCPTransferObserver::ECCPLocalTransfer );
                break;
                }
            // The call has been placed on hold by the remote connected party
            case RMobileCall::ERemoteHold:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Remotely held" );
                iObserver.NotifyCallEventOccurred( 
                        MCCPCallObserver::ECCPRemoteHold );
                break;
                }
            // The call has been resumed by the remote connected party. 
            case RMobileCall::ERemoteResume:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Remotely resumed" );
                iObserver.NotifyCallEventOccurred( 
                        MCCPCallObserver::ECCPRemoteResume );
                break;
                }
            // The call has been joined by the remote connected party to other
            // call(s) to create/add to a conference call. 
            case RMobileCall::ERemoteConferenceCreate:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Remotely created \
                             conference" );
                
                iObserver.NotifyCallEventOccurred( 
                        MCCPCallObserver::ECCPRemoteConferenceCreate );
                        
                break;
                }
            case RMobileCall::ERemoteTransferring:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Remotely created \
                     conference" );
                iObserver.NotifyTransferCallEventOccurred( 
                        MCCPTransferObserver::ECCPRemoteTransferring );
                break;
                }
            case RMobileCall::ERemoteTransferAlerting:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Remotely created \
                     conference" );
                iObserver.NotifyTransferCallEventOccurred( 
                            MCCPTransferObserver::ECCPRemoteTransferAlerting );
                break;
                }
            // The outgoing call has been barred by the remote party
            case RMobileCall::ERemoteBarred:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Remotely barred" );
                iObserver.NotifyCallEventOccurred( 
                        MCCPCallObserver::ECCPRemoteBarred );
                break;
                }

            // The call is being forwarded by the remote party. 
            case RMobileCall::ERemoteForwarding:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Remotely forwarded" );
                iObserver.NotifyForwardEventOccurred( 
                        MCCPForwardObserver::ECCPRemoteForwarding );
                break;
                }

            // The call is waiting at the remote end. 
            case RMobileCall::ERemoteWaiting:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Remotely waiting" );
                iObserver.NotifyCallEventOccurred( 
                        MCCPCallObserver::ECCPRemoteWaiting );
                break;
                }

            // The outgoing call has been barred by the local party. 
            case RMobileCall::ELocalBarred:
                {
                CSPLOGSTRING( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Locally barred" );
                iObserver.NotifyCallEventOccurred( 
                        MCCPCallObserver::ECCPLocalBarred );
                break;
                }

            default:
                {
                CSPLOGSTRING2( CSPINT, 
                    "CSP CSPEtelCallEventMonitor::RunL: Unspecified/protocol \
                     specific call event: %d", iCallEvent );
                break;
                }
            }
        }
        
    if ( !destroyed )
        {
        // In case instance has not been deleted, pointer must be cleared.
        iDestrPtr = NULL;
        if ( iStatus == KErrNone )
            {
            StartMonitoring();
            }
        }
    else
        {
        // already destroyed, do not touch members.
        }
    }

// ---------------------------------------------------------------------------
// From CActive
// Request canceling.
// ---------------------------------------------------------------------------
//
void CSPEtelCallEventMonitor::DoCancel()
    {
    CSPLOGSTRING( CSPINT, "CSPEtelCallEventMonitor::DoCancel" );
    iCall.CancelAsyncRequest( EMobileCallNotifyCallEvent );
    }
    
// ---------------------------------------------------------------------------
// Constructs the monitor.
// ---------------------------------------------------------------------------
//
CSPEtelCallEventMonitor::CSPEtelCallEventMonitor( MCSPCallObserver& aObserver,
                                                  RMobileCall& aCall ) : 
                                   CActive( EPriorityStandard ), 
                                   iObserver( aObserver ),
                                   iCall ( aCall )
    {
    CSPLOGSTRING(CSPOBJECT, 
        "CSPEtelCallEventMonitor::CSPEtelCallEventMonitor()" );
    CActiveScheduler::Add( this );
    }

// End of File