/*
* Copyright (c) 2002-2010 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:  Base class of protocol profile handlers.
*
*/


#include "scpservicehandlerbase.h"
#include "scpprofilehandler.h"
#include "scputility.h"
#include "scplogger.h"
#include "scpservicestorage.h"
#include "scpsubservice.h"

// If sub service disconnection fails a timeout for
// forced disabled is used.
const TInt KDisableTimeout = 5000000;

// -----------------------------------------------------------------------------
// CScpServiceHandlerBase::CScpServiceHandlerBase
// -----------------------------------------------------------------------------
//
CScpServiceHandlerBase::CScpServiceHandlerBase( CScpSubService& aSubService ) :
    iSubService( aSubService )
    {
    SCPLOGSTRING2( "CScpServiceHandlerBase[0x%x]::CScpServiceHandlerBase", this); 
    }

// -----------------------------------------------------------------------------
// CScpServiceHandlerBase::~CScpServiceHandlerBase
// -----------------------------------------------------------------------------
//
CScpServiceHandlerBase::~CScpServiceHandlerBase()
    {
    SCPLOGSTRING2( "CScpServiceHandlerBase[0x%x]::~CScpServiceHandlerBase",this); 

    delete iDisableTimer;

    CScpProfileHandler& profileHandler = iSubService.ProfileHandler();
    profileHandler.RemoveObserver( *this );
    }

// -----------------------------------------------------------------------------
// CScpServiceHandlerBase::BaseConstructL
// -----------------------------------------------------------------------------
//
void CScpServiceHandlerBase::BaseConstructL()
    {
    SCPLOGSTRING2( "CScpServiceHandlerBase[0x%x]::BaseConstructL", this );

    CScpProfileHandler& profileHandler = iSubService.ProfileHandler();
    profileHandler.AddObserverL( *this );
    
    iDisableTimer = CPeriodic::NewL( 0 );
    }

// -----------------------------------------------------------------------------
// From base class MScpSipConnectionObserver
// CScpServiceHandlerBase::IsSipProfileAllowedToStartAlr
// -----------------------------------------------------------------------------
//
TBool CScpServiceHandlerBase::IsSipProfileAllowedToStartAlr()
    {
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CScpServiceHandlerBase::RegisterProfileL
// -----------------------------------------------------------------------------
//
void CScpServiceHandlerBase::RegisterProfileL()
    {
    SCPLOGSTRING2( "CScpServiceHandlerBase[0x%x]::RegisterProfileL", this );

    CScpProfileHandler& profileHandler = iSubService.ProfileHandler();
    profileHandler.RegisterProfileL( iSubService.SipProfileId() );

    CScpSipConnection::TConnectionState currentState = CScpSipConnection::EUnknown;
    TInt error = KErrNone;

    profileHandler.GetCurrentState( iSubService.SipProfileId(), 
                                     currentState,
                                     error );

    __ASSERT_DEBUG( currentState != CScpSipConnection::EUnknown, 
                    User::Panic( KNullDesC, KErrGeneral ) );

    TScpConnectionEvent event = TScpUtility::ConvertToConnectionEvent( currentState,
                                                                       error );
    if ( event == EScpRegistered )
        {
        // Sip profile was already registered
        HandleSipConnectionEvent( iSubService.SipProfileId(), EScpRegistered );
        }
    else
        {
        iSubService.HandleConnectionEvent( event );
        }
    }

// -----------------------------------------------------------------------------
// CScpServiceHandlerBase::DeregisterProfile
// -----------------------------------------------------------------------------
//
void CScpServiceHandlerBase::DeregisterProfile()
    {
    SCPLOGSTRING2( "CScpServiceHandlerBase[0x%x]::DeregisterProfile", this );

    // At this point all the service related disconnection operations
    // have been finished. Now the SIP profile needs to be disabled
    iSubService.SetSubServiceDisconnected( ETrue );

    TInt sipProfileId = iSubService.SipProfileId(); 
    CScpServiceStorage& storage = iSubService.ServiceStorage();

    // The SIP profile can be only disabled if
    // - None of the sub services are in enable state with the same profile
    // - None of the sub services are doing disconnection with the same profile
    if ( !storage.IsSubServiceEnabled( sipProfileId ) &&
         storage.AreAllSubServicesDisconnected( sipProfileId ) )
        {  
        CScpSipConnection::TConnectionState currentState = 
            CScpSipConnection::EUnknown;
        TInt error( KErrNone );        

        CScpProfileHandler& profileHandler = iSubService.ProfileHandler();
        profileHandler.GetCurrentState( sipProfileId, 
                                         currentState,
                                         error );        

        if ( currentState == CScpSipConnection::ERegistering )
            {
            profileHandler.CancelRegistration( sipProfileId );
            }
        else
            {
            error = profileHandler.UnregisterProfile( sipProfileId );
            if ( KErrNotFound == error )
                {
                SCPLOGSTRING3(
                        "CScpServiceHandlerBase[0x%x]::DeregisterProfile - No profile with ID: %d",
                        this,
                        sipProfileId );
                }
            }
        }

    StartForcedDisableTimer( CScpServiceHandlerBase::ForceSipProfileDisable );
    }

// -----------------------------------------------------------------------------
// CScpServiceHandlerBase::PerformInstantForceSipProfileDisable
// -----------------------------------------------------------------------------
//
void CScpServiceHandlerBase::PerformInstantForceSipProfileDisable()
    {
    SCPLOGSTRING2( 
        "CScpServiceHandlerBase[0x%x]::PerformInstantForceSipProfileDisable", 
        this );
    HandleSipProfileForcedDisable( ETrue );
    }

// -----------------------------------------------------------------------------
// CScpServiceHandlerBase::StartForcedDisableTimer
// -----------------------------------------------------------------------------
//
void CScpServiceHandlerBase::StartForcedDisableTimer( TInt (*aFunction)(TAny* aPtr) )
    {
    SCPLOGSTRING2( "CScpServiceHandlerBase[0x%x]::StartForcedDisableTimer", this );
    __ASSERT_DEBUG( !iDisableTimer->IsActive(), 
                    User::Panic( KNullDesC, KErrGeneral ) );

    if ( !iDisableTimer->IsActive() )
        {
        iDisableTimer->Start( KDisableTimeout, 
                              0, 
                              TCallBack( aFunction, this ) );
        }
    }

// -----------------------------------------------------------------------------
// CScpServiceHandlerBase::CancelDisableTimer
// -----------------------------------------------------------------------------
//
void CScpServiceHandlerBase::CancelDisableTimer()
    {
    SCPLOGSTRING2( "CScpServiceHandlerBase[0x%x]::CancelDisableTimer", this );

    if ( iDisableTimer->IsActive() )
        {
        iDisableTimer->Cancel();
        }
    }

// -----------------------------------------------------------------------------
// CScpServiceHandlerBase::HandleSipProfileForcedDisable
// -----------------------------------------------------------------------------
//
void CScpServiceHandlerBase::HandleSipProfileForcedDisable( 
    TBool aForceDisableSipProfile )
    {
    SCPLOGSTRING2( 
        "CScpServiceHandlerBase[0x%x]::HandleSipProfileForcedDisable", this );

    if ( aForceDisableSipProfile )
        {
        CScpProfileHandler& profileHandler = iSubService.ProfileHandler();
    
        CScpSipConnection* sipConnection = 
            profileHandler.GetSipConnection( iSubService.SipProfileId() );
      
        if ( sipConnection )
            {
            sipConnection->ForceDisable();
            }
        }
    
    HandleSipConnectionEvent( iSubService.SipProfileId(), EScpDeregistered );
    }

// -----------------------------------------------------------------------------
// CScpServiceHandlerBase::ForceSipProfileDisable
// -----------------------------------------------------------------------------
//
TInt CScpServiceHandlerBase::ForceSipProfileDisable( TAny* aSelf )
    {
    SCPLOGSTRING( "CScpServiceHandlerBase::ForceSipProfileDisable" );

    CScpServiceHandlerBase* self = static_cast<CScpServiceHandlerBase*>( aSelf );
    
    self->CancelDisableTimer();
    self->HandleSipProfileForcedDisable( EFalse );

    return 1;
    }


//  End of File