/*

* 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:  Monitors the VOIP calls.

*

*/

#include <e32property.h>

#include <telephonydomainpskeys.h>

// Call Information API

#include <ccallinformation.h>

// SP Settings

#include <spdefinitions.h>

#include <spentry.h>

#include <spproperty.h>

#include <spsettings.h>

#include "musvoipcallmonitor.h"

#include "mussesseioninformationapi.h"

#include "muslogger.h"

const TUint KMusAoRemoteInfoMonitoringTimeout = 2000000; // 2 seconds

_LIT( KSipAt, "@" );

// -----------------------------------------------------------------------------

// Symbian two-phase constructor.

// -----------------------------------------------------------------------------

//

CMusVoipCallMonitor* CMusVoipCallMonitor::NewL( TName& aCallName, 

                                        MMusCallStateObserver& aCallStateObserver )

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::NewL" )

    CMusVoipCallMonitor* self = 

                new (ELeave) CMusVoipCallMonitor( aCallName, aCallStateObserver );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::NewL" )

    return self;

    }

// -----------------------------------------------------------------------------

// C++ destructor.

// -----------------------------------------------------------------------------

//

CMusVoipCallMonitor::~CMusVoipCallMonitor()

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::~CMusVoipCallMonitor" )    

    ResetCallProviderName();

    StopRemoteInfoMonitoring();

    iPropertyEvent.Close();

    delete iGuardTimer;

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::~CMusVoipCallMonitor" )

    }

// -----------------------------------------------------------------------------

// C++ constructor.

// -----------------------------------------------------------------------------

//

CMusVoipCallMonitor::CMusVoipCallMonitor( TName& aCallName, 

                                        MMusCallStateObserver& aCallStateObserver ):

    CActive( CActive::EPriorityStandard ),

    iCallName ( aCallName ),

    iCallStateObserver ( aCallStateObserver ),

    iGuardTimerCallBack( GuardTimerExpired, this ) 

    {    

    CActiveScheduler::Add( this );

    iGuardTimerEntry.Set( iGuardTimerCallBack );

    }

// -----------------------------------------------------------------------------

// Symbian second-phase constructor.

// -----------------------------------------------------------------------------

//

void CMusVoipCallMonitor::ConstructL( )

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::ConstructL" ) 

    User::LeaveIfError( iPropertyEvent.Attach(

        KPSUidTelRemotePartyInformation,

        KTelCLINumber ) );

    iGuardTimer = CDeltaTimer::NewL( CActive::EPriorityStandard );

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::ConstructL" )

    }

// -----------------------------------------------------------------------------

// CMusVoipCallMonitor::SetStateL( )

// Sets the call state property key.See mussesseioninformationapi.h

// Also sets the call information if call state is Connected.

// If call is connected but remote info cannot be found, information

// publishing is delayed until remote info comes available or monitoring

// for the info timeouts. In voip case, remote info should be basically

// always available, but in some cases it is not immediately available

// when call status changes to connected.

// -----------------------------------------------------------------------------

//

void CMusVoipCallMonitor::SetStateL(NMusSessionInformationApi::TMusCallEvent aVal)

    {    

    MUS_LOG1( "mus: [MUSAO]  -> CMusVoipCallMonitor::SetStateL, aVal %d", aVal )

    // set the call state only if the call count is one else it should be decided 

    // by conference monitor or line/tsy monitor.

    TBool delayStateChange( EFalse );

    if ( aVal == NMusSessionInformationApi::ECallConnected )

        {

        if ( !RemoteInfoExistsL() )

            {

            MonitorForRemoteInfoL();

            delayStateChange = ETrue;

            }

        }

    else

        {

        StopRemoteInfoMonitoring();

        }

    if ( delayStateChange )

        {

        MUS_LOG( "mus: [MUSAO]      state change delayed!" )   

        }

    else

        {

        ReportStateChangeL( aVal );

        }

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::SetStateL" )    

    }

///-----------------------------------------------------------------------------

// CMusVoipCallMonitor::SetCallInfoL( )

// -----------------------------------------------------------------------------

//

void CMusVoipCallMonitor::SetCallInfoL()

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::SetCallInfoL")     

    // Set Call Provider Information

    TUint32 serviceId = CallServiceIdL();

    SetCallProviderInfoL( serviceId );

    HBufC* remoteUri = HBufC::NewLC( RProperty::KMaxPropertySize );

    TPtr rUri = remoteUri->Des();

    TInt err = RProperty::Get( KPSUidTelRemotePartyInformation,

                               KTelCLINumber,

                               rUri );

    if ( err == KErrNone && remoteUri->Des().Length() > 0 )

        {

        MUS_LOG_TDESC( "mus: [MUSAO] voip remote name: ", remoteUri->Des());

        // Add "sip:" prefix to remoteUri unless it already exists

        _LIT( KSipPrefix, "sip:" );

        TPtr prefix = remoteUri->Des().LeftTPtr( KSipPrefix().Length() );

        if ( prefix.Compare( KSipPrefix ) != 0 )

            {

            if ( remoteUri->Des().Length() + KSipPrefix().Length() >

                 remoteUri->Des().MaxLength() )

                {

                User::Leave( KErrOverflow );

                }

            remoteUri->Des().Insert( 0, KSipPrefix );

            }

        //if domain not present, add domain from voip profile (username)

        if ( remoteUri->Find( KSipAt ) == KErrNotFound )

            {

            rUri.Set( remoteUri->Des() );

            AddDomainFromOwnUsernameL( serviceId, rUri );

            MUS_LOG_TDESC ( "mus: [MUSAO] full voip remote name:", (*remoteUri) )

            }

        }

    else

        {

        remoteUri->Des().Zero();

        }

    User::LeaveIfError( RProperty::Set(

            NMusSessionInformationApi::KCategoryUid,

            NMusSessionInformationApi::KMusTelNumber, remoteUri->Des() ) );

    CleanupStack::PopAndDestroy(remoteUri);

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::SetCallInfoL" )  

    }

///-----------------------------------------------------------------------------

// CMusVoipCallMonitor::AddDomainFromOwnUsernameL( )

// -----------------------------------------------------------------------------

//

void CMusVoipCallMonitor::AddDomainFromOwnUsernameL( 

    TUint32 /*aServiceId*/, 

    TDes16& /*aUri*/ )

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::AddDomainFromOwnUsernameL")

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::AddDomainFromOwnUsernameL, NOT SUPPORTED")

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::AddDomainFromOwnUsernameL")

    }

///-----------------------------------------------------------------------------

// CMusVoipCallMonitor::CallServiceIdL( )

// -----------------------------------------------------------------------------

//

TUint32 CMusVoipCallMonitor::CallServiceIdL()

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::CallServiceIdL")

    TUint32 serviceId( 0 );

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::CallServiceIdL, NOT SUPPORTED")

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::CallServiceIdL")

    return serviceId;

    }

///-----------------------------------------------------------------------------

// CMusVoipCallMonitor::SetCallProviderInfoL( )

// -----------------------------------------------------------------------------

//

void CMusVoipCallMonitor::SetCallProviderInfoL( TUint32 aServiceId )

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::SetCallProviderInfoL")

    CSPSettings* settings = CSPSettings::NewLC();    

    CSPEntry* entry = CSPEntry::NewLC();

    TInt errorCode = settings->FindEntryL( aServiceId, *entry );

    if ( errorCode == KErrNone && entry != NULL ) 

        {

        const TDesC& name = entry->GetServiceName();    

        MUS_LOG_TDESC ( "mus: [MUSAO]]  CallProviderName IS -->", name )

        User::LeaveIfError(RProperty::Set( 

                                        NMusSessionInformationApi::KCategoryUid,

                                        NMusSessionInformationApi::KMUSCallProvider,

                                        name));

        }

    CleanupStack::PopAndDestroy( entry );

    CleanupStack::PopAndDestroy( settings );

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::SetCallProviderInfoL" )  

    }

// -----------------------------------------------------------------------------

// Checks the aName is equal to this monitors name.

// @return ETrue if matches else EFalse

// -----------------------------------------------------------------------------

//

TBool CMusVoipCallMonitor::IsEqual(TName& aName)

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::IsEqual" )

    MUS_LOG_TDESC( "mus: [MUSAO]  -> aName : ", aName );

    MUS_LOG_TDESC( "mus: [MUSAO]  -> iCallName : ", iCallName );

    TBool val = EFalse ;    

    val = ( aName == iCallName );    

    MUS_LOG1( "mus: [MUSAO]  <- CMusCallMonitor::IsEqual = %d",val )

    return val;

    }

// -----------------------------------------------------------------------------

// CMusVoipCallMonitor::RunL

// -----------------------------------------------------------------------------

//

void CMusVoipCallMonitor::RunL()

    {

    MUS_LOG( "mus: [MUSAO] -> CMusVoipCallMonitor::RunL" )

    if ( RemoteInfoExistsL() )

        {

        // Connected state reporting was delayed because not having

        // remote info, now it can be reported and monitoring is not needed anymore

        StopRemoteInfoMonitoring();

        ReportStateChangeL( NMusSessionInformationApi::ECallConnected  );

        }

    else

        {

        // resubscribe

        iPropertyEvent.Subscribe( iStatus );    

        SetActive();

        }

    MUS_LOG( "mus: [MUSAO] <- CMusVoipCallMonitor::RunL" )

    }

// -----------------------------------------------------------------------------

// CMusVoipCallMonitor::DoCancel

// -----------------------------------------------------------------------------

//

void CMusVoipCallMonitor::DoCancel()

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::DoCancel" )

    iPropertyEvent.Cancel();

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::DoCancel" )

    }

// -----------------------------------------------------------------------------

// CMusVoipCallMonitor::RunError

// -----------------------------------------------------------------------------

//

TInt CMusVoipCallMonitor::RunError( TInt aError )

    {

    MUS_LOG1( "mus: [MUSAO]  -> CMusVoipCallMonitor::RunError = %d", aError )    

    if ( aError != KErrNoMemory )

        {

        aError = KErrNone;

        }

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::RunError" )

    return aError;    

    }

// -----------------------------------------------------------------------------

// CMusVoipCallMonitor::RemoteInfoExistsL

// -----------------------------------------------------------------------------

//

TBool CMusVoipCallMonitor::RemoteInfoExistsL()

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::RemoteInfoExistsL" )

    HBufC* remoteUri = HBufC::NewLC(RProperty::KMaxPropertySize);

    TPtr rUri = remoteUri->Des();

    TInt err = RProperty::Get( KPSUidTelRemotePartyInformation,

                                 KTelCLINumber,

                                 rUri );

    TBool remoteInfoExists( err == KErrNone && remoteUri->Des().Length() > 0 );

    CleanupStack::PopAndDestroy(remoteUri);

    MUS_LOG1( "mus: [MUSAO]  <- CMusVoipCallMonitor::RemoteInfoExistsL = %d", 

              remoteInfoExists )    

    return remoteInfoExists;

    }

// -----------------------------------------------------------------------------

// CMusVoipCallMonitor::MonitorForRemoteInfoL

// Start monitoring remote info P&S key. Guard timer is started

// to prevent waiting for the infomation forever.

// -----------------------------------------------------------------------------

//

void CMusVoipCallMonitor::MonitorForRemoteInfoL()

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::MonitorForRemoteInfoL" )

    if ( !IsActive() )

        {

        MUS_LOG( "mus: [MUSAO]      activate" )

        iGuardTimer->Remove( iGuardTimerEntry );

        TTimeIntervalMicroSeconds32 interval( KMusAoRemoteInfoMonitoringTimeout );

        iGuardTimer->Queue( interval, iGuardTimerEntry );

        iPropertyEvent.Subscribe( iStatus );    

        SetActive();

        }

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::MonitorForRemoteInfoL" )

    }

// -----------------------------------------------------------------------------

// CMusVoipCallMonitor::MonitorForRemoteInfoL

// -----------------------------------------------------------------------------

//

void CMusVoipCallMonitor::StopRemoteInfoMonitoring()

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::StopRemoteInfoMonitoring" )

    if ( iGuardTimer )

        {

        iGuardTimer->Remove( iGuardTimerEntry );

        }

    Cancel();

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::StopRemoteInfoMonitoring" )

    }

// -----------------------------------------------------------------------------

// CMusVoipCallMonitor::ReportStateChangeL

// -----------------------------------------------------------------------------

//

void CMusVoipCallMonitor::ReportStateChangeL( 

    NMusSessionInformationApi::TMusCallEvent aVal )

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::ReportStateChangeL" )

    TInt currentVal = 0;

    User::LeaveIfError(RProperty::Get( NMusSessionInformationApi::KCategoryUid,

                                       NMusSessionInformationApi::KMusCallEvent,

                                       currentVal));

    // Report only if the value changed else do not publish.

    if(currentVal != (TInt)aVal)

        {

        User::LeaveIfError(RProperty::Set( 

                                   NMusSessionInformationApi::KCategoryUid,

                                   NMusSessionInformationApi::KMusCallEvent,

                                   aVal ));    

        }        

    // When call is connected and the callcount is one, 

    // set the call informations.

    if( aVal==NMusSessionInformationApi::ECallConnected ) 

        {

        SetCallInfoL();

        }  

    iCallStateObserver.MusCallStateChanged();

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::ReportStateChangeL" )

    }

// -----------------------------------------------------------------------------

// CMusVoipCallMonitor::GuardTimerExpired

// If timer expired, it took too long to get remote party information via

// P&S monitoring. Because of monitoring, call connected was not yet informed,

// inform it now.

// -----------------------------------------------------------------------------

//

TInt CMusVoipCallMonitor::GuardTimerExpired( TAny* aPtr )

    {

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::GuardTimerExpired" )

    if ( aPtr )

        {

        CMusVoipCallMonitor* self = reinterpret_cast<CMusVoipCallMonitor*>( aPtr );

        self->StopRemoteInfoMonitoring();

        TRAP_IGNORE( 

                self->ReportStateChangeL( NMusSessionInformationApi::ECallConnected ) )

        }

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::GuardTimerExpired" )

    return KErrNone;

    }

// --------------------------------------------------------------------------------

// CMusCallConferenceMonitor::IsDataReadyL()

// Checks if Data is ready VoIP Call.

// --------------------------------------------------------------------------------

TBool CMusVoipCallMonitor::IsDataReadyL()

    {

    //This function need to updated if some other P/S Key is published

    //to ensure correct behaviour.

    MUS_LOG( "mus: [MUSAO]  -> CMusVoipCallMonitor::IsDataReadyL" )

    // Ensure Provider Information is Availble.

    HBufC* providerInfo = HBufC::NewLC( RProperty::KMaxPropertySize );

    TPtr pInfo = providerInfo->Des();

    TInt err  = KErrNone;

    err = RProperty::Get( NMusSessionInformationApi::KCategoryUid,

                                NMusSessionInformationApi::KMUSCallProvider,

                                 pInfo );

    TBool providerInfoExisit ( err == KErrNone && providerInfo->Des().Length() > 0 );

    CleanupStack::PopAndDestroy( providerInfo );

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::IsDataReadyL" )

    return !IsActive() && providerInfoExisit;

    }

// --------------------------------------------------------------------------------

// Reset the Call Provider Information. 

// --------------------------------------------------------------------------------

void CMusVoipCallMonitor::ResetCallProviderName( )

    {

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::ResetCallProviderName" )

    TInt errorCode = RProperty::Set( NMusSessionInformationApi::KCategoryUid,

                                 NMusSessionInformationApi::KMUSCallProvider,

                                 KNullDesC );

    // Error Code is just for debug only 

    MUS_LOG1( "mus: [MUSAO]  ErrorCode = %d", errorCode )

    MUS_LOG( "mus: [MUSAO]  <- CMusVoipCallMonitor::ResetCallProviderName" )

    }

// End of file