/*
* Copyright (c) 2005-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:   class to watch call monitor event properties
*
*/



#include "musavacalleventmonitor.h"
#include "muslogger.h"
#include "mussesseioninformationapi.h"
#include "musresourceproperties.h"
#include "muscallmonitorobserver.h"
#include <e32property.h>

// --------------------------------------------------------------------------
// Two phase constructor NewL()
// --------------------------------------------------------------------------
//
CMusAvaCallEventMonitor* CMusAvaCallEventMonitor::NewL(
    MMusCallMonitorObserver& aObserver )
    {
    MUS_LOG( "mus: [MUSAOP]  -> CMusAvaCallEventMonitor::NewL" )
    CMusAvaCallEventMonitor* self = 
        new (ELeave) CMusAvaCallEventMonitor( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    MUS_LOG( "mus: [MUSAOP]  <- CMusAvaCallEventMonitor::NewL" )
    return self;
    }

// --------------------------------------------------------------------------
// Destructor
// --------------------------------------------------------------------------
//
CMusAvaCallEventMonitor::~CMusAvaCallEventMonitor()
    {
    MUS_LOG( "-> CMusAvaCallEventMonitor::~CMusAoPlugin" )
    
    MUS_LOG( "<- CMusAvaCallEventMonitor::~CMusAoPlugin" )
    }

// --------------------------------------------------------------------------
// Constructor 
// --------------------------------------------------------------------------
//
CMusAvaCallEventMonitor::CMusAvaCallEventMonitor( 
    MMusCallMonitorObserver& aObserver )
    :CActive( EPriorityNormal ),
    iObserver( aObserver )
    {
    }

// --------------------------------------------------------------------------
// Two phase constructor ConstructL()
// --------------------------------------------------------------------------
//
void CMusAvaCallEventMonitor::ConstructL()
    {
    MUS_LOG( "mus: [MUSAOP]  -> CMusAvaCallEventMonitor::ConstructL" )
    CActiveScheduler::Add( this );
    MUS_LOG( "mus: [MUSAOP]  <- CMusAvaCallEventMonitor::ConstructL" )
    }


// --------------------------------------------------------------------------
// Returns the status of the call
// --------------------------------------------------------------------------
//
TInt CMusAvaCallEventMonitor::CallStatusL()
    {
    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  -> CMusAvaCallEventMonitor::\
        CallStatusL" )    
    TInt callStatus;
    User::LeaveIfError( RProperty::Get(
        NMusSessionInformationApi::KCategoryUid,
        NMusSessionInformationApi::KMusCallEvent,
        callStatus ) );

    MUS_LOG1( "mus: [CMusAvaCallEventMonitor]     Call Event = %d ", 
        callStatus )    
    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  <- CMusAvaCallEventMonitor::\
        CallStatusL" )    
    return callStatus;
    }

// --------------------------------------------------------------------------
// Returns the direction of connected call.
// --------------------------------------------------------------------------
//
TInt CMusAvaCallEventMonitor::CallDirectionL()
    {
    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  -> CMusAvaCallEventMonitor::\
        CallDirectionL" )
    // retrieve call count
    TInt direction( 0 );
    User::LeaveIfError( RProperty::Get(
        NMusSessionInformationApi::KCategoryUid,
        NMusSessionInformationApi::KMusCallDirection,
        direction ) );

    MUS_LOG1( "mus: [CMusAvaCallEventMonitor]     Call Direction = %d ", 
        direction )
    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  <- CMusAvaCallEventMonitor::\
        CallDirectionL" )
    return direction;
    }
    
// --------------------------------------------------------------------------
// Returns the direction of connected call.
// --------------------------------------------------------------------------
//
TInt CMusAvaCallEventMonitor::CallPrivacyL()
    {
    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  -> CMusAvaCallEventMonitor::\
            CallPrivacyL" )
    // retrieve call count
    TInt privacy( 0 );
    User::LeaveIfError( RProperty::Get(
        NMusSessionInformationApi::KCategoryUid,
        NMusSessionInformationApi::KMUSPrivacy,
        privacy ) );

    MUS_LOG1( "mus: [CMusAvaCallEventMonitor]     Call privacy = %d ", 
            privacy )
    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  <- CMusAvaCallEventMonitor::\
        CallPrivacyL" )
    return privacy;
    }
	
// --------------------------------------------------------------------------
// aTelNumber will be filled with telephone number of current connected call
// --------------------------------------------------------------------------
//
void CMusAvaCallEventMonitor::GetTelNumberL( TDes& aTelNumber )
    {
    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  -> CMusAvaCallEventMonitor::\
        GetTelNumberL" )
    TBuf<KMusTelNumberMaxLength> telNumber;

    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  CMusAvaCallEventMonitor::\
        GetTelNumberL - a" )
    TInt error = RProperty::Get(
        NMusSessionInformationApi::KCategoryUid,
        NMusSessionInformationApi::KMusTelNumber,
        telNumber );

    MUS_LOG1( "mus: [CMusAvaCallEventMonitor]  CMusAvaCallEventMonitor::\
        GetTelNumberL (%d)", error )

    if ( error != KErrOverflow )
        {
        User::LeaveIfError( error );
        }

    TInt length = telNumber.Length();
    TInt maxLength = aTelNumber.MaxLength();
    if ( maxLength < length )
        {
        // buffer is too small for returned tel number.
        MUS_LOG2( "mus: [CMusAvaCallEventMonitor]  CMusAvaCallEventMonitor::\
            GetTelNumberL - Buffer too small (%d, %d), leave", 
            maxLength, length )
        User::Leave( KErrOverflow );
        }

    aTelNumber.Copy( telNumber );
    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  <- CMusAvaCallEventMonitor::\
        GetTelNumberL" )
    }


// --------------------------------------------------------------------------
// Subscribe to the property, means start monitoring the property
// --------------------------------------------------------------------------
//
void CMusAvaCallEventMonitor::StartMonitoringL()
    {
    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  -> CMusAvaCallEventMonitor::\
        StartMonitoringL" )
    if ( !IsActive() )
        {
        MUS_LOG( "mus: [CMusAvaCallEventMonitor]   CMusAvaCallEventMonitor::\
            StartMonitoringL - Not active, starting" )
        User::LeaveIfError( iPropertyEvent.Attach(
            NMusSessionInformationApi::KCategoryUid,
            NMusSessionInformationApi::KMusCallEvent ) );
        // initial subscription and process current property value
        iPropertyEvent.Subscribe( iStatus );
        SetActive();
        }
    MUS_LOG( "mus: [CMusAvaCallEventMonitor]  <- CMusAvaCallEventMonitor::\
        StartMonitoringL" )
    }


// --------------------------------------------------------------------------
// Called by Cancel()
// --------------------------------------------------------------------------
//
void CMusAvaCallEventMonitor::DoCancel()
    {
    iPropertyEvent.Cancel();
    iPropertyEvent.Close();
    }


// --------------------------------------------------------------------------
// Active Object RunL implementation. Will be called when property changes.
// --------------------------------------------------------------------------
//
void CMusAvaCallEventMonitor::RunL()
    {
    MUS_LOG( "mus: [MUSAOP]  -> CMusAvaCallEventMonitor::RunL" )

    // resubscribe before processing new value to prevent missing updates
    iPropertyEvent.Subscribe( iStatus );
    SetActive();

    // property updated, get new value
    TInt callStatus;
    if ( iPropertyEvent.Get( callStatus ) == KErrNotFound )
        {
        // property deleted
        iObserver.NoActiveCallL();
        }
    else
        {
        switch( callStatus )
            {
            case NMusSessionInformationApi::ENoCall:
                {
                iObserver.NoActiveCallL();
                break;
                }

            case NMusSessionInformationApi::ECallConnected:
                {
                // retrieve telnumber
                TInt error;
                TBuf<KMusTelNumberMaxLength> telNumber;
                error = RProperty::Get(
                    NMusSessionInformationApi::KCategoryUid,
                    NMusSessionInformationApi::KMusTelNumber,
                    telNumber );

                if ( error != KErrOverflow )
                    {
                    User::LeaveIfError( error );
                    }

                iObserver.CallConnectedL( telNumber );
                break;
                }

            case NMusSessionInformationApi::ECallHold:
                {
                 // retrieve telnumber
                TInt error;
                TBuf<KMusTelNumberMaxLength> telNumber;
                error = RProperty::Get(
                    NMusSessionInformationApi::KCategoryUid,
                    NMusSessionInformationApi::KMusTelNumber,
                    telNumber );

                if ( error != KErrOverflow )
                    {
                    User::LeaveIfError( error );
                    }
                iObserver.CallHoldL( telNumber );
                break;
                }

            case NMusSessionInformationApi::EConferenceCall:
                {
                iObserver.ConferenceCallL();
                break;
                }

            default:
                {
                iObserver.NoActiveCallL();
                break;
                }
            }
        }

    MUS_LOG( "mus: [MUSAOP]  <- CMusAvaCallEventMonitor::RunL" )
    }


// --------------------------------------------------------------------------
// RunL leaves will be handled here. Make sure it returns KErrNone
// Otherwise Active Scheduler Error() will be called.
// --------------------------------------------------------------------------
//
TInt CMusAvaCallEventMonitor::RunError( TInt aError )
    {
    MUS_LOG1( "mus: [MUSAOP]  -> CMusAvaCallEventMonitor::RunError(%d)",
        aError )

    // Not much things can be done here as cleanup operation.
    aError = KErrNone;

    MUS_LOG( "mus: [MUSAOP]  <- CMusAvaCallEventMonitor::RunError" )
    return aError;
    }