/*

* Copyright (c) 2007-2009 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:  Interface to SIP profiles.

*

*/

#include <sipprofileregistry.h>

#include <sipprofile.h>

#include <sipmanagedprofile.h>

#include <sipmanagedprofileregistry.h>

#include <sipconnection.h>

#include <commdb.h>

#include <ccherror.h>

#include "scpsipconnection.h"

#include "scplogger.h"

#include "scpsipconnectionobserver.h"

#include "scputility.h"

#include "voipeventlog.h"

// If EnableL fails a timeout for reporting error

const TInt KEnableTimeout = 120000000;

const TInt KUsernameMaxLength = 255;

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

// CScpSipConnection::CScpSipConnection

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

//

CScpSipConnection::CScpSipConnection( 

    TInt aProfileId, 

    CSIPProfileRegistry& aProfileRegistry,

    CSIPManagedProfileRegistry& aManagedProfileRegistry,

    CSIP& aSip ) :

    iProfileId( aProfileId ),

    iProfileRegistry( aProfileRegistry ),

    iManagedProfileRegistry( aManagedProfileRegistry ),

    iSip( aSip ),

    iRegistrationRequestState( ENoRequest ),

    iConnectionStateError( KErrNone ),

    iReserved( EFalse ),

    iIapAvailableOffered( EFalse )

    {

    SCPLOGSTRING3( "CScpSipConnection[0x%x]::CScpSipConnection profile id: %d", 

                   this, aProfileId );

    }

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

// CScpSipConnection::ConstructL

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

//

void CScpSipConnection::ConstructL()

    {

    SCPLOGSTRING2( "CScpSipConnection[0x%x]::ConstructL", this );

    iSipProfile = iProfileRegistry.ProfileL( iProfileId );

    if ( !iSipProfile )

        {

        User::Leave( KErrNotFound );

        }

    iEnableTimeoutTimer = CPeriodic::NewL( CPeriodic::EPriorityStandard );

    User::LeaveIfError( iConnectionMonitor.ConnectL() );

    }

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

// CScpSipConnection::NewL

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

//

CScpSipConnection* CScpSipConnection::NewL( 

    TInt aProfileId, 

    CSIPProfileRegistry& aProfileRegistry,

    CSIPManagedProfileRegistry& aManagedProfileRegistry,

    CSIP& aSip )

    {

    SCPLOGSTRING( "CScpSipConnection::NewL" );

    __ASSERT_DEBUG( aProfileId > 0, User::Panic( KNullDesC, KErrGeneral ) );

    CScpSipConnection* self = new (ELeave) CScpSipConnection( aProfileId,

                                                              aProfileRegistry,

                                                              aManagedProfileRegistry,

                                                              aSip );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CScpSipConnection::~CScpSipConnection

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

//

CScpSipConnection::~CScpSipConnection()

    {  

    SCPLOGSTRING2( "CScpSipConnection[0x%x]::~CScpSipConnection", this );

    delete iSipConnection;

    iConnectionMonitor.Close();

    delete iEnableTimeoutTimer;

    delete iSipProfile;

    }

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

// CScpSipConnection::AddObserver

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

//

void CScpSipConnection::AddObserver( MScpSipConnectionObserver& aObserver )

    {

    SCPLOGSTRING3( "CScpSipConnection[0x%x]::AddObserverL: 0x%x",this, &aObserver );

    iObserver = &aObserver;

    } 

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

// CScpSipConnection::RemoveObserver

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

//

TInt CScpSipConnection::RemoveObserver( MScpSipConnectionObserver& aObserver )

    {

    SCPLOGSTRING3( "CScpSipConnection[0x%x]::RemoveObserver: 0x%x", this, &aObserver );

    if ( &aObserver == iObserver )

        {

        iObserver = NULL;

        return KErrNone;

        }

    return KErrNotFound;

    }

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

// CScpSipConnection::ProfileId

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

//

TInt CScpSipConnection::ProfileId() const

    {

    SCPLOGSTRING2( "CScpSipConnection[0x%x]::ProfileId", this );

    return iProfileId;

    }

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

// CScpSipConnection::EnableL

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

//

void CScpSipConnection::EnableL()

    {

    SCPLOGSTRING2( "CScpSipConnection[0x%x]::EnableL", this );

    if ( iRegistrationRequestState != ERegistrationRequested )

        {

        iConnectionStateError = KErrNone;

        iRegistrationRequestState = ERegistrationRequested;

        TUint32 iapId( 0 );

        TUint32 snapId( 0 );

        TInt result = GetSnap( snapId );

        if ( result == KErrNotFound || snapId == 0 )

            {

            SCPLOGSTRING2( "CScpSipConnection[0x%x]::EnableL - SNAP not found", this );

            result = GetIap( iapId );

            }

        // If username is not set leave directly with KCCHErrorAuthenticationFailed

        if ( !IsUsernameSetL() )

            {

            SCPLOGSTRING2( "CScpSipConnection[0x%x]::EnableL - AuthenticationFailed !!!", this );

            User::Leave( KCCHErrorAuthenticationFailed );

            }

        iProfileRegistry.EnableL( *iSipProfile, *this );

        if ( !iSipConnection && 0 != iapId )

             {

             iSipConnection = CSIPConnection::NewL( iSip, iapId, *this );

             }

        TBool connectionAvailable = IsNetworkConnectionAvailable();

        if ( connectionAvailable )

            {

            TBool registered( EFalse );

            User::LeaveIfError( iSipProfile->GetParameter( KSIPProfileRegistered, 

                                                           registered ) );

            if ( !registered )

                {

                StartEnableTimeoutTimer( CScpSipConnection::EnableTimeout );

                }

            }        

        else

            {

            iConnectionStateError = KCCHErrorNetworkLost;

            }

        }

    }

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

// CScpSipConnection::Disable

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

//

TInt CScpSipConnection::Disable()

    {

    SCPLOGSTRING2( "CScpSipConnection[0x%x]::Disable", this );

    iRegistrationRequestState = EDeregistrationRequested;

    CancelEnableTimeoutTimer();

    delete iSipConnection;

    iSipConnection = NULL;

    TInt err = iProfileRegistry.Disable( *iSipProfile );

    TRAPD( err1, DisableAlwaysOnModeL() );

    if ( err == KErrNone )

        {

        err = err1;

        }

    return err;

    }

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

// CScpSipConnection::DisableAlwaysOnModeL()

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

//

void CScpSipConnection::DisableAlwaysOnModeL()

    {

    SCPLOGSTRING2( "CScpSipConnection[0x%x]::DisableAlwaysOnModeL", this );

    TBool autoRegistration( EFalse );

    User::LeaveIfError( iSipProfile->GetParameter( KSIPAutoRegistration, 

                                                   autoRegistration ) );

    if ( autoRegistration )

        {

        CSIPManagedProfile* profile = static_cast<CSIPManagedProfile*> ( iSipProfile );

        User::LeaveIfError( profile->SetParameter( KSIPAutoRegistration, EFalse ) );

        iManagedProfileRegistry.SaveL( *profile );

        }

    }

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

// CScpSipConnection::RegistrationRequestState

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

//

CScpSipConnection::TRegistrationRequestState 

    CScpSipConnection::RegistrationRequestState() const

    {

    SCPLOGSTRING2( "CScpSipConnection[0x%x]::RegistrationRequestState", this );

    return iRegistrationRequestState;

    }

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

// CScpSipConnection::GetState

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

//

void CScpSipConnection::GetState( CScpSipConnection::TConnectionState& aState,

                                  TInt& aError ) const

    {

    SCPLOGSTRING2( "CScpSipConnection[0x%x]::GetState", this );

    aError = iConnectionStateError;

    TBool registered( EFalse );

    TInt result = iSipProfile->GetParameter( KSIPProfileRegistered, registered );

    if ( result == KErrNone )

        {

        switch ( iRegistrationRequestState )

            {

            case ENoRequest:

                if( registered )

                    {

                    aState = ERegistered;

                    }

                else

                    {

                    aState = EDeregistered;

                    }

                break;

            case ERegistrationRequested:

                if ( registered )

                    {

                    aState = ERegistered;

                    }

                else

                    {

                    aState = ERegistering;

                    }

                break;

            case EDeregistrationRequested:

                if ( registered )

                    {

                    aState = EDeregistering;

                    }

                else

                    {

                    aState = EDeregistered;

                    }

                break;

            default:

                __ASSERT_DEBUG( EFalse, User::Panic( KNullDesC, KErrGeneral ) );

                break;

            }

        }

    }

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

// CScpSipConnection::ProfileRegistryEventOccurred

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

//

void CScpSipConnection::ProfileRegistryEventOccurred( 

    MSIPProfileRegistryObserver::TEvent aEvent )

    {

    SCPLOGSTRING3( "CScpSipConnection[0x%x]::ProfileRegistryEventOccurred event: %d", 

                   this, aEvent );

    TScpConnectionEvent event( EScpUnknown );

    switch ( aEvent )

        {

        case MSIPProfileRegistryObserver::EProfileRegistered:

            {

            CancelEnableTimeoutTimer();

            delete iSipConnection;

            iSipConnection = NULL;

            iConnectionStateError = KErrNone;

            event = EScpRegistered;

            }

            break;

        case MSIPProfileRegistryObserver::EProfileDeregistered:

            {

            CancelEnableTimeoutTimer();

            if ( iRegistrationRequestState == EDeregistrationRequested )

                {

                iConnectionStateError = KErrNone;

                event = EScpDeregistered;            

                }

            else

                {

                // SIP will still notify the client with 

                // MSIPProfileRegistryObserver::ProfileRegistryEventOccurred( EProfileDeregistered ) 

                // but the reason for this event can be checked by the client

                // by calling CSIPProfileRegistryBase::LastRegistrationError.

                // If this function returns KErrDisconnected,

                // the client can determine that the reason for the event was that the network connection was dropped.

                TInt lastRegistrationError =

                    iProfileRegistry.LastRegistrationError( *iSipProfile );

                SCPLOGSTRING2( "    -> last registration error: %d", lastRegistrationError );

                if (  KErrDisconnected != lastRegistrationError )

                    {

                    if ( iProfileCurrentlyRoaming )

                        {

                        iProfileCurrentlyRoaming = EFalse;

                        iConnectionStateError = KCCHErrorNetworkLost;

                        event = EScpNetworkLost;

                        }

                    else

                        {

                        iConnectionStateError = KErrNone;

                        event = EScpDeregistered;

                        } 

                    }

                else

                    {

                    iConnectionStateError = KCCHErrorNetworkLost;

                    event = EScpNetworkLost;

                    }

                }

            }

            break;

        case MSIPProfileRegistryObserver::EProfileUpdated:

            {

            // Should we start EnableTimeoutTimer if registration

            // was requested?

            if ( iProfileCurrentlyRoaming )

                {

                iProfileCurrentlyRoaming = EFalse;

                iConnectionStateError = KErrNone;

                event = EScpRegistered;

                }

            }

            break;

        default:

            break;

        }

    if ( event != EScpUnknown && iObserver )

        {

        SCPLOGSTRING3( "id: %d HandleSipConnectionEvent event: %d", 

                       iProfileId, event );

        iObserver->HandleSipConnectionEvent( iProfileId, event );

        }

    }

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

// CScpSipConnection::ProfileRegistryErrorOccurred

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

//

void CScpSipConnection::ProfileRegistryErrorOccurred( TInt aError )

    {

    SCPLOGSTRING3( "CScpSipConnection[0x%x]::ProfileRegistryErrorOccurred error: %d", 

                   this, aError );

    CancelEnableTimeoutTimer();

    iConnectionStateError = TScpUtility::ConvertToCchError( aError );

    TScpConnectionEvent event = EScpUnknown;

    if ( iConnectionStateError == KCCHErrorAuthenticationFailed )

        {

        event = EScpAuthenticationFailed;

        }

    else if ( iConnectionStateError == KCCHErrorInvalidSettings )

        {

        event = EScpInvalidSettings;

        }

    else

        {

        if ( KErrCancel == aError )

            {

            iConnectionStateError = KErrCancel;

            event = EScpRegistrationCanceled;

            iRegistrationRequestState = EDeregistrationRequested;

            }

        else

            {

            iConnectionStateError = KCCHErrorLoginFailed;

            event = EScpRegistrationFailed;

            }

        }    

    TInt error = KErrNone;

    CVoipEventLog* eventLog = NULL;

    TRAP( error, eventLog = CVoipEventLog::NewL() );

    if ( KErrNone == error )

        {

        eventLog->WriteError( aError );

        }

    delete eventLog;

    iObserver->HandleSipConnectionEvent( iProfileId, event );    

    }

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

// CScpSipConnection::StartEnableTimeoutTimer

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

//

void CScpSipConnection::StartEnableTimeoutTimer( TInt (*aFunction)(TAny* aPtr) )

    {

    SCPLOGSTRING2( "CScpSipConnection[0x%x]::StartEnableTimeoutTimer", this );

    __ASSERT_DEBUG( !iEnableTimeoutTimer->IsActive(), 

                    User::Panic( KNullDesC, KErrGeneral ) );

    if ( !iEnableTimeoutTimer->IsActive() )

        {

        iEnableTimeoutTimer->Start( KEnableTimeout, 

                              0, 

                              TCallBack( aFunction, this ) );

        }

    }

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

// CScpSipConnection::CancelEnableTimeoutTimer

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

//

void CScpSipConnection::CancelEnableTimeoutTimer()

    {

    SCPLOGSTRING2( "CScpSipConnection[0x%x]::CancelEnableTimeoutTimer", this );

    if ( iEnableTimeoutTimer->IsActive() )

        {

        iEnableTimeoutTimer->Cancel();

        }

    }

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

// CScpSipConnection::EnableTimeout

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

//

TInt CScpSipConnection::EnableTimeout( TAny* aSelf )

    {

    SCPLOGSTRING( "CScpSipConnection::EnableTimeout" );

    CScpSipConnection* self = static_cast<CScpSipConnection*>( aSelf );

    self->HandleEnableTimeout();

    return 0;

    }

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