/*

* 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:  

*

*/

#include <sip.h>

#include <sipprofileregistry.h>

#include <sipprofilealrcontroller.h>

#include <sipprofile.h>

#include <sipmanagedprofile.h>

#include <sipmanagedprofileregistry.h>

#include <ctsydomainpskeys.h>

#include <bamdesca.h>

#include <sipprofileregistryobserver.h> 

#include "ipvmbxinterface.h"

#include "scpprofilehandler.h"

#include "scplogger.h"

#include "scpsipconnection.h"

#include "cipappphoneutils.h"

#include "cipapputilsaddressresolver.h"

#include "scputility.h"

const TInt KTempStringlength = 200;

const TUint KSCPUserAgentStringLength = 12;

const TUint KSCPWlanMacAddressLength = 50;

const TUint KSCPMaxTerminalTypeLength = 64;

_LIT( KScpUserAgentString, "User-Agent: " );

_LIT8 ( KSCPWlanMacAddressFrmt, "-" );

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

// CScpProfileHandler::CScpProfileHandler

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

//

CScpProfileHandler::CScpProfileHandler()

    {

    }

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

// CScpProfileHandler::ConstructL

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

//

void CScpProfileHandler::ConstructL()

    {

    SCPLOGSTRING( "CScpProfileHandler::ConstructL" );

    iSip = CSIP::NewL( TUid::Null(), *this );

    iProfileRegistry = CSIPProfileRegistry::NewL( *iSip, *this );

    iManagedProfileRegistry = CSIPManagedProfileRegistry::NewL( *this );

    iAlrController = CSipProfileAlrController::NewL( *iProfileRegistry,

                                                     *this );

    }

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

// CScpProfileHandler::NewL

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

//

CScpProfileHandler* CScpProfileHandler::NewL()

    {

    CScpProfileHandler* self =  new ( ELeave ) CScpProfileHandler();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CScpProfileHandler::~CScpProfileHandler

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

//

CScpProfileHandler::~CScpProfileHandler()

    {  

    SCPLOGSTRING( "CScpProfileHandler::~CScpProfileHandler" );

    iObservers.Close();

    iSipConnections.ResetAndDestroy();

    iSipConnections.Close();

    delete iVmbxInterface;

    delete iAlrController;

    delete iManagedProfileRegistry;

    delete iProfileRegistry;    

    delete iSip;

    }

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

// CScpProfileHandler::AddObserverL

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

//

void CScpProfileHandler::AddObserverL( MScpSipConnectionObserver& aObserver )

    {

    SCPLOGSTRING2( "CScpProfileHandler::AddObserverL: 0x%x", &aObserver );

    TInt result = iObservers.Find( &aObserver );

    if ( result == KErrNotFound )

        {

        iObservers.AppendL( &aObserver );

        }

    else

        {

        User::Leave( KErrAlreadyExists );

        }

    }

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

// CScpProfileHandler::RemoveObserver

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

//

TInt CScpProfileHandler::RemoveObserver( MScpSipConnectionObserver& aObserver )

    {

    SCPLOGSTRING2( "CScpProfileHandler::RemoveObserver: 0x%x", &aObserver );

    TInt result = iObservers.Find( &aObserver );

    if ( result != KErrNotFound )

        {

        iObservers.Remove( result );

        return KErrNone;

        }

    return KErrNotFound;

    }

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

// CScpProfileHandler::GetCurrentState

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

//

TInt CScpProfileHandler::GetCurrentState( TUint32 aProfileId, 

    CScpSipConnection::TConnectionState& aState,

    TInt& aError ) const

    {

    SCPLOGSTRING( "CScpProfileHandler::GetCurrentState" );

    TInt result( KErrNone );

    // Go through own sip profiles and check state

    // If not found, create SipConnection and check state

    CScpSipConnection* sipConnection = GetSipConnection( aProfileId );

    TBool sipConnectionCreated = EFalse;

    if( !sipConnection )

        {

        sipConnectionCreated = ETrue;

        TRAP( result, sipConnection = CreateSipConnectionL( aProfileId ) );

        }

    if( result == KErrNone )

        {

        sipConnection->GetState( aState, aError );

        }

    if( sipConnectionCreated )

        {

        delete sipConnection;

        }

    return result;

    }

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

// CScpProfileHandler::RegisterProfileL

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

//

void CScpProfileHandler::RegisterProfileL( TUint32 aProfileId )

    {

    SCPLOGSTRING2("CScpProfileHandler::RegisterProfileL profile id: %d", aProfileId );

    // Check if sip connection already exists

    TBool found( EFalse );

    CScpSipConnection* sipConnection( NULL );

    for( TInt i=0; i<iSipConnections.Count(); i++ )

        {

        sipConnection = iSipConnections[ i ];

        if( sipConnection->ProfileId() == aProfileId )

            {

            found = ETrue;

            sipConnection->EnableL();

            break;

            }    

        }

    // Otherwise create it

    if( !found )

        {

        sipConnection = CreateSipConnectionL( aProfileId );

        CleanupStack::PushL( sipConnection );        

        // try enabling

        sipConnection->AddObserver( *this );

        sipConnection->EnableL();

        // add to array

        iSipConnections.AppendL( sipConnection );

        CleanupStack::Pop( sipConnection );

        }

    }

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

// CScpProfileHandler::SipConnectionExists

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

//

TBool CScpProfileHandler::SipConnectionExists( TUint32 aProfileId ) const

    {

    SCPLOGSTRING2("CScpProfileHandler::SipConnectionExists profile id: %d", aProfileId );

    return ( GetSipConnection( aProfileId ) != NULL );

    }

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

// CScpProfileHandler::GetSipConnection

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

//

CScpSipConnection* CScpProfileHandler::GetSipConnection( TUint32 aProfileId ) const

    {

    SCPLOGSTRING2("CScpProfileHandler::GetSipConnection profile id: %d", aProfileId );

    CScpSipConnection* sipConnection( NULL );

    for( TInt i=0; i<iSipConnections.Count(); i++ )

        {

        sipConnection = iSipConnections[ i ];

        if( sipConnection->ProfileId() == aProfileId )

            {

            return sipConnection;

            }    

        }

    return NULL;

    }

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

// CScpProfileHandler::CreateSipConnectionL

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

//

CScpSipConnection* CScpProfileHandler::CreateSipConnectionL( TUint32 aProfileId ) const

    {

    SCPLOGSTRING2("CScpProfileHandler::CreateSipConnectionL profile: %d", aProfileId);

    return CScpSipConnection::NewL( aProfileId,

                                    *iProfileRegistry,

                                    *iManagedProfileRegistry,

                                    *iSip );

    }

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

// CScpProfileHandler::UnRegisterProfile

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

//

TInt CScpProfileHandler::UnregisterProfile( TUint32 aProfileId )

    {

    SCPLOGSTRING2("CScpProfileHandler::UnregisterProfile id: %d", aProfileId );

    CScpSipConnection* sipConnection( NULL );    

    for( TInt i=0; i<iSipConnections.Count(); i++ )

        {

        sipConnection = iSipConnections[ i ];

        if( sipConnection->ProfileId() == aProfileId )

            {

            return sipConnection->Disable();

            }

        }

    return KErrNotFound;

    }

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

// CScpProfileHandler::CancelRegistration

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

//

TInt CScpProfileHandler::CancelRegistration( TUint32 aProfileId )

    {

    SCPLOGSTRING2("CScpProfileHandler::UnregisterProfile id: %d", aProfileId );

    TInt result = UnregisterProfile( aProfileId );

    if( result == KErrNone ||

        result == KErrNotFound || 

        result == KErrArgument )

        {

        result = RemoveSipConnection( aProfileId );

        }

    return result;

    }

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

// CScpProfileHandler::IncomingRequest

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

//

void CScpProfileHandler::IncomingRequest( TUint32 /*aIapId*/,

                                          CSIPServerTransaction* /*aTransaction*/ )

    {

    SCPLOGSTRING( "CScpProfileHandler::IncomingRequest" );

    }

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

// CScpProfileHandler::TimedOut

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

//

void CScpProfileHandler::TimedOut(

    CSIPServerTransaction& /*aTransaction*/ )

    {

    SCPLOGSTRING( "CScpProfileHandler::TimedOut" );

    }

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

// CScpProfileHandler::RemoveSipConnection

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

//

TInt CScpProfileHandler::RemoveSipConnection( TUint32 aProfileId )

    {

    SCPLOGSTRING2( "CScpProfileHandler::RemoveSipConnection id: %i", 

                   aProfileId );

    TInt ret = ( KErrNotFound );

    CScpSipConnection* sipConnection( NULL );

    sipConnection =  GetSipConnection( aProfileId );

    if ( sipConnection )

        {

        TInt index = iSipConnections.Find( sipConnection );

        iSipConnections.Remove( index );

        delete sipConnection;

        ret = KErrNone;

        }

    return ret;

    }

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

// CScpProfileHandler::ProfileRegistryEventOccurred

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

//

void CScpProfileHandler::ProfileRegistryEventOccurred(

    TUint32 aProfileId,

    MSIPProfileRegistryObserver::TEvent aEvent )

    {

    SCPLOGSTRING3( "CScpProfileHandler::ProfileRegistryEventOccurred id: %i event: %d", 

                   aProfileId, aEvent );

    CScpSipConnection* sipConnection = GetSipConnection( aProfileId );

    if( sipConnection )

        {

        sipConnection->ProfileRegistryEventOccurred( aEvent );

        // Deal with sip profile removals

        switch ( aEvent )

            {

            case EProfileDeregistered:

                {

                // Remove sip connection only if user has requested deregistration

                CScpSipConnection::TRegistrationRequestState state =

                    sipConnection->RegistrationRequestState();

                if( state == CScpSipConnection::EDeregistrationRequested )

                    {

                    RemoveSipConnection( aProfileId );

                    }

                }

                break;

            case EProfileDestroyed:

                {

                RemoveSipConnection( aProfileId );

                }

                break;

            default:

                break;

            }

        }      

    }

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

// CScpProfileHandler::ProfileRegistryErrorOccurred

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

//

void CScpProfileHandler::ProfileRegistryErrorOccurred( TUint32 aProfileId,

                                                       TInt aError )

    {

    SCPLOGSTRING3( "CScpProfileHandler::ProfileRegistryErrorOccurred profile:%i error: %d", 

                   aProfileId, aError );

    CScpSipConnection* sipConnection = GetSipConnection( aProfileId );

    if( sipConnection )

        {

        sipConnection->ProfileRegistryErrorOccurred( aError );

        }

    }

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

// CScpProfileHandler::ProfileExist

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

//

TBool CScpProfileHandler::ProfileExists( TUint32 aProfileId ) const

    {    

    SCPLOGSTRING2( "CScpProfileHandler::ProfileExists id: %d", aProfileId );

    CSIPProfile* profile( NULL );

    TRAPD( result, profile = iProfileRegistry->ProfileL( aProfileId ) );

    if( result == KErrNone && profile )

        {

        delete profile;

        return ETrue;

        }

    return EFalse;             

    }

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

// CScpProfileHandler::SetSipProfileReserved

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

//

void CScpProfileHandler::SetSipProfileReserved( TUint32 aProfileId, TBool aReserved )

    {

    SCPLOGSTRING3( "CScpProfileHandler::SetSipProfileReserved id: %d reserved: %d", 

                   aProfileId, aReserved );

    CScpSipConnection* sipConnection = GetSipConnection( aProfileId );

    if( sipConnection )

        {

        sipConnection->SetReserved( aReserved );

        // If profile was freed and iap availability alr event had come

        // before, let ALR controller to know that the profile is up

        // for ALR

        if( aReserved == EFalse && 

            sipConnection->IapAvailableOffered() )

            {

            TRAP_IGNORE( iAlrController->RefreshIapAvailabilityL( aProfileId ) );

            // Reset the iap availability offered flag

            sipConnection->SetIapAvailableOffered( EFalse );

            }

        }

    }

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

// CScpProfileHandler::AlrEvent

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

//

void CScpProfileHandler::AlrEvent( MSipProfileAlrObserver::TEvent aEvent,

                                   TUint32 aProfileId,

#ifdef _DEBUG

                                   TUint32 aSnapId,

#else

                                   TUint32 /*aSnapId*/,

#endif

                                   TUint32 aIapId )

    {

    SCPLOGSTRING2("CScpProfileHandler::AlrEvent profile:%i", aProfileId);

    SCPLOGSTRING2("CScpProfileHandler::AlrEvent aEvent:%i", (TInt)aEvent);

    SCPLOGSTRING2("CScpProfileHandler::AlrEvent aSnapId:%i", aSnapId);

    SCPLOGSTRING2("CScpProfileHandler::AlrEvent aIapId:%i", aIapId);

    CScpSipConnection* sipConnection( NULL );

    switch( aEvent )

        {

        case MSipProfileAlrObserver::EIapAvailable:

            {

            TBool reserved( EFalse );

            sipConnection = GetSipConnection( aProfileId );

            if( sipConnection )

                {

                reserved = sipConnection->Reserved();

                if( reserved )

                    {

                    TRAPD( result, 

                        iAlrController->DisallowMigrationL( aProfileId, aIapId ) );

                    if( result == KErrNone )

                        {

                        // Raise the iap availability offered flag

                        sipConnection->SetIapAvailableOffered( ETrue );

                        }

                    }

                else

                    {

                    sipConnection->SetProfileCurrentlyRoaming();

                    TRAP_IGNORE(

                        iAlrController->AllowMigrationL( aProfileId, aIapId ) );

                    }

                }

            break;

            }

        // For possible beyond use (E.g. Maybe we should change CHH state

        // during iap migration -> VoIP call not possible if iap migration

        // ongoing.)

        case MSipProfileAlrObserver::EMigrationStarted:

            {

            sipConnection = GetSipConnection( aProfileId );

            if( sipConnection )

                {

                sipConnection->HandleMigrationStarted();

                }

            break;

            }