/*
* Copyright (c) 2005-2006 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:  Monitor the status of CS Conference call
*
*/
 

#include "mussesseioninformationapi.h"
#include "muslogger.h"
#include "muscallconferencemonitor.h"
#include "muscallconferenceeventmonitor.h"

#include <etelmm.h>
#include <e32svr.h>
#include <mmtsy_names.h>
#include <e32property.h>


// -----------------------------------------------------------------------------
// Symbian two-phase constructor.
// -----------------------------------------------------------------------------
//
CMusCallConferenceMonitor* CMusCallConferenceMonitor::NewL( RMobilePhone& aPhone,
                              RMobileLine& aLine,
                              RPointerArray<CMusCallMonitor>& aCallMonitorArray )
    {
    MUS_LOG( "mus: [MUSAO]  -> CMusCallConferenceMonitor::NewL" )
    CMusCallConferenceMonitor* self = new (ELeave) 
                              CMusCallConferenceMonitor(aLine,aCallMonitorArray);
    CleanupStack::PushL( self );
    self->ConstructL( aPhone );
    CleanupStack::Pop( self );
    MUS_LOG( "mus: [MUSAO]  <- CMusCallConferenceMonitor::NewL" )
    return self;
    }


// -----------------------------------------------------------------------------
// C++ destructor.
// -----------------------------------------------------------------------------
//
CMusCallConferenceMonitor::~CMusCallConferenceMonitor()
    {
    MUS_LOG( "mus: [MUSAO]  -> \
                        CMusCallConferenceMonitor::~CMusCallConferenceMonitor" )        
    Cancel();   
    iConfCall.Close();
    delete iConfCallEvent;
    MUS_LOG( "mus: [MUSAO]  <- \
                        CMusCallConferenceMonitor::~CMusCallConferenceMonitor" )
    }

// -----------------------------------------------------------------------------
// Symbian second-phase constructor.
// -----------------------------------------------------------------------------
//
void CMusCallConferenceMonitor::ConstructL( RMobilePhone& aPhone )
    {
    MUS_LOG( "mus: [MUSAO]  -> CMusCallConferenceMonitor::ConstructL" )   
    CActiveScheduler::Add( this );            
    User::LeaveIfError(iConfCall.Open(aPhone));    
    iConfCall.NotifyConferenceStatusChange(iStatus,iConfStatus);   
    SetActive();    
    iConfCallEvent = CMusCallConferenceEventMonitor::NewL(aPhone,
                                                          iLine,
                                                          iCallMonitorArray); 
    MUS_LOG( "mus: [MUSAO]  <- CMusCallConferenceMonitor::ConstructL" )
    }


// -----------------------------------------------------------------------------
// C++ constructor.
// -----------------------------------------------------------------------------
//
CMusCallConferenceMonitor::CMusCallConferenceMonitor(RMobileLine& aLine,
                            RPointerArray<CMusCallMonitor>& aCallMonitorArray) 
        : CActive( EPriorityNormal ),
          iLine(aLine),
          iCallMonitorArray(aCallMonitorArray)
          
        
    {    
    }


// --------------------------------------------------------------------------------
// CMusCallConferenceMonitor::RunL()
// Implemented for CActive.It will be called any NotifyMobileLineStatusChange
// Event happens.
// --------------------------------------------------------------------------------
//
void CMusCallConferenceMonitor::RunL()
    {
    MUS_LOG( "mus: [MUSAO]  -> CMusCallConferenceMonitor::RunL" )    
    iConfCall.NotifyConferenceStatusChange(iStatus,iConfStatus); 
    SetActive();       
    MUS_LOG1( "mus: [MUSAO]  Conference->iCallStatus =  %d", iConfStatus ) 
    switch(iConfStatus)    
        {         
            case RMobileConferenceCall::EConferenceIdle:
                 MonitorCallL();                                	
                 break;
            case RMobileConferenceCall::EConferenceActive:	                 
                 SetStateL( NMusSessionInformationApi::EConferenceCall );
                 break;
            case RMobileConferenceCall::EConferenceHold:
                 SetStateL(NMusSessionInformationApi::ECallHold);	
                 break;
            default:
                 break;
        }
    MUS_LOG( "mus: [MUSAO]  <- CMusCallConferenceMonitor::RunL" )
    }


// --------------------------------------------------------------------------------
// CMusCallConferenceMonitor::DoCancel()
// Implemented for CActive.
// Will be called when Cancel() method is called.
// --------------------------------------------------------------------------------
//
void CMusCallConferenceMonitor::DoCancel()
    {
    MUS_LOG( "mus: [MUSAO]  -> CMusCallConferenceMonitor::DoCancel" )
    iConfCall.CancelAsyncRequest( EMobileConferenceCallNotifyConferenceStatusChange );
    MUS_LOG( "mus: [MUSAO]  <- CMusCallConferenceMonitor::DoCancel" )
    }

// --------------------------------------------------------------------------------
// CMusCallConferenceMonitor::RunError( TInt aError )
// Implemented for CActive.
// Will be called automatically by framework when RunL Leaves.
// --------------------------------------------------------------------------------
//

TInt CMusCallConferenceMonitor::RunError( TInt aError )
    {
    MUS_LOG1( "mus: [MUSAO]  -> CMusCallConferenceMonitor::RunError, aError %d", \
                                                                          aError )
    aError = KErrNone;
    MUS_LOG( "mus: [MUSAO]  <- CMusCallConferenceMonitor::RunError" )    
    return aError;
    }


// --------------------------------------------------------------------------------
// CMusCallConferenceMonitor::SetStateL()
// Sets the Call State to Property
// --------------------------------------------------------------------------------
//
void CMusCallConferenceMonitor::SetStateL()
    {
    MUS_LOG( "mus: [MUSAO]  -> CMusCallConferenceMonitor::SetStateL")    
    User::LeaveIfError(iConfCall.GetConferenceStatus(iConfStatus));    
    MUS_LOG1( "mus: [MUSAO]  Conference->iCallStatus =  %d", iConfStatus ) 
    switch(iConfStatus)    
        {         
            case RMobileConferenceCall::EConferenceIdle:                 
                 break;
            case RMobileConferenceCall::EConferenceActive:	                 
                 SetStateL( NMusSessionInformationApi::EConferenceCall );
                 break;
            case RMobileConferenceCall::EConferenceHold:
                 SetStateL(NMusSessionInformationApi::ECallHold);	
                 break;
            default:
                 break;
        }
    MUS_LOG( "mus: [MUSAO]  <- CMusCallConferenceMonitor::SetStateL" )    
    }


// --------------------------------------------------------------------------------
// CMusCallConferenceMonitor::SetStateL( TInt aError )
// Sets the Call State to Property
// --------------------------------------------------------------------------------
//
void CMusCallConferenceMonitor::SetStateL(
                                      NMusSessionInformationApi::TMusCallEvent aVal)
    {
    MUS_LOG1( "mus: [MUSAO]  -> CMusCallConferenceMonitor::SetStateL, aVal %d",\
                                                                              aVal )
    TInt currentVal;
    User::LeaveIfError(RProperty::Get( NMusSessionInformationApi::KCategoryUid,
                     NMusSessionInformationApi::KMusCallEvent,currentVal));
    if(currentVal != (TInt)aVal)
        {
        User::LeaveIfError(RProperty::Set( NMusSessionInformationApi::KCategoryUid,
                     NMusSessionInformationApi::KMusCallEvent,
                     aVal ));    
        }
    else
        {
         // No point of reporting it .
        }    
    MUS_LOG( "mus: [MUSAO]  <- CMusCallConferenceMonitor::SetStateL" )    
    }

// --------------------------------------------------------------------------------
// CMusCallConferenceMonitor::MonitorCallL() 
// If the call in conference is dropped that has to be removed.
// from call monitoring array.and start monitoring.
// --------------------------------------------------------------------------------
//
void CMusCallConferenceMonitor::MonitorCallL()
    {
    MUS_LOG( "mus: [MUSAO]  -> CMusCallConferenceMonitor::MonitorCallL")
    TInt callCount;
    iLine.EnumerateCall(callCount);
    MUS_LOG1( "mus: [MUSAO]  -> callCount = %d",callCount)    
    RLine::TCallInfo callInfo;
    for(TInt i=0;i<callCount;i++)
        {
        MUS_LOG( "mus: [MUSAO]  -----------------------------------\n" )
        iLine.GetCallInfo(i,callInfo);
        MUS_LOG1( "mus: [MUSAO]  Call index = %d",i)
        MUS_LOG_TDESC("mus: [MUSAO]  Call Name",callInfo.iCallName);
        MUS_LOG1( "mus: [MUSAO]  Call Status = %d",callInfo.iStatus );        
        if(callInfo.iStatus == RCall::EStatusIdle)
            {
            for ( TInt j = 0; j < iCallMonitorArray.Count(); j++ )
                {
                if( iCallMonitorArray[j]->IsEqual( callInfo.iCallName ) )
                    {
                    delete iCallMonitorArray[j];
                    iCallMonitorArray.Remove(j);                   
                    break;
                    }
                }
            }                   
        MUS_LOG( "mus: [MUSAO]  -----------------------------------\n" ) 
        }

    MUS_LOG( "mus: [MUSAO]  -> CMusCallConferenceMonitor::CheckCallStatus")
    }

// End of file