/*

* 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:  Vmbx handler.

*

*/

#include "ipvmbxinterface.h"

#include "scpvmbxhandler.h"

#include "scplogger.h"

#include "scpservice.h"

#include "scpsubservice.h"

#include "scpservicestorage.h"

#include "scputility.h"

#include "scpsipconnection.h"

#include "scpprofilehandler.h"

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

// CScpVmbxHandler::CCScpVmbxHandler

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

//

CScpVmbxHandler::CScpVmbxHandler( CScpSubService& aSubService ) :

    CScpServiceHandlerBase( aSubService )

    {

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

    }

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

// CScpVmbxHandler::ConstructL

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

//

void CScpVmbxHandler::ConstructL()

    {

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

    BaseConstructL();

    }

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

// CScpVmbxHandler::NewL

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

//

CScpVmbxHandler* CScpVmbxHandler::NewL( CScpSubService& aSubService )

    {

    SCPLOGSTRING( "CScpVmbxHandler::NewL" );

    CScpVmbxHandler* self = new(ELeave) CScpVmbxHandler( aSubService );

    CleanupStack::PushL( self );    

    self->ConstructL();    

    CleanupStack::Pop( self );

    return self;

    }

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

// CScpVmbxHandler::~CScpVmbxHandler

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

//

CScpVmbxHandler::~CScpVmbxHandler()

    {

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

    if ( !IsAnotherVmbxSubServiceAlreadyEnabled() )

        {

        iSubService.ProfileHandler().DeleteVmbxInterface();

        }

    }

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

// CScpVmbxHandler::EnableSubServiceL

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

//

void CScpVmbxHandler::EnableSubServiceL()

    {

    SCPLOGSTRING4( "CScpVmbxHandler[0x%x]::EnableSubServiceL: 0x%x type: %i", 

                   this, &iSubService, iSubService.SubServiceType() );

    __ASSERT_DEBUG( iSubService.SubServiceType() == ECCHVMBxSub,

                    User::Panic( KNullDesC, KErrGeneral ) );

    // Only one enabled vmbx service is allowed at a time.

    if( IsAnotherVmbxSubServiceAlreadyEnabled() )

        {

        User::Leave( KErrInUse );

        }

    CScpServiceHandlerBase::RegisterProfileL();

    }

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

// CScpVmbxHandler::IsAnotherVmbxSubServiceAlreadyEnabled

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

//

TBool CScpVmbxHandler::IsAnotherVmbxSubServiceAlreadyEnabled() const

    {

    SCPLOGSTRING2( "CScpVmbxHandler[0x%x]::IsAnotherVmbxSubServiceAlreadyEnabled", this );

    TBool result = EFalse;

    CScpServiceStorage& storage = iSubService.ServiceStorage();

    RArray<TInt> ids;

    storage.GetSubServiceIds( ECCHVMBxSub, ids );

    TInt count( ids.Count() );

    for ( TInt i( 0 ); i < count; i++ )

        {

        CScpSubService* subService = storage.GetSubService( ids[i] );

        if ( subService && ECCHDisabled != subService->State() )

            {

            result = ETrue;

            break;

            }

        }

    ids.Close();

    return result;

    }

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

// CScpVmbxHandler::DisableSubService

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

//

TInt CScpVmbxHandler::DisableSubService()

    {

    SCPLOGSTRING4( "CScpVmbxHandler[0x%x]::DisableSubService: 0x%x type: %i", 

                   this, &iSubService, iSubService.SubServiceType() );

    __ASSERT_DEBUG( iSubService.SubServiceType() == ECCHVMBxSub,

                    User::Panic( KNullDesC, KErrGeneral ) );  

    TInt result = KErrNone;

    if( iSubService.State() != ECCHDisabled )

        {

        TRAP( result, UnsubscribeL() );

        if( result == KErrNone )

            {

            // Deregister if still connecting and subscribed message 

            // not yet received

            if( iSubService.State() == ECCHConnecting )

                {

                DeregisterProfile();

                }

            else

                {

                StartForcedDisableTimer( CScpVmbxHandler::ForceVmbxServiceDisable );

                }

            }

        else

            {

            DeregisterProfile();

            }

        }

    else

        {

        result = KErrNotSupported;

        }

    return result;

    }

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

// CScpVmbxHandler::UnsubscribeL

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

//

void CScpVmbxHandler::UnsubscribeL()

    {

    SCPLOGSTRING2( "CScpVmbxHandler[0x%x]::UnsubscribeL", this );

    CScpProfileHandler& profileHandler = iSubService.ProfileHandler();

    // Unsubscribe is not called when refreshing the connection

    if( iSubService.EnableRequestedState() != CScpSubService::EScpRefreshed )

        {

        CIpVmbxInterface& vmbxInterface = profileHandler.VmbxInterfaceL( *this );

        vmbxInterface.UnsubscribeL( iSubService.SubServiceId() );

        }

    }

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

// CScpVmbxHandler::HandleMessage

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

//

void CScpVmbxHandler::HandleMessage( TUint32 aServiceId, TVmbxMessage aMessage )

    {

    SCPLOGSTRING4( "CScpVmbxHandler[0x%x]::HandleMessage: id: %d message: %d", 

                   this, aServiceId, aMessage );

    TInt result = KErrNone;

    if( iSubService.SubServiceId() == aServiceId )

        {

        switch( aMessage )

            {

            case ESubscribed:

                {

                iSubService.HandleConnectionEvent( EScpRegistered );

                }

                break;

            case EUnsubscribed:

                {

                // Check if disable was requested

                if( iSubService.EnableRequestedState() == CScpSubService::EScpDisabled )

                    {

                    CancelDisableTimer();

                    DeregisterProfile();

                    }

                else

                    {

                    if ( iResubscribe )

                        {

                        iResubscribe = EFalse;

                        TRAP( result, SubscribeL() )

                        SCPLOGSTRING2( "Subscribe result: %d", result ); 

                        if( result == KErrNone )

                            {

                            // Still connecting the service

                            iSubService.HandleConnectionEvent( EScpNetworkFound );

                            }

                        else if ( KErrAlreadyExists == result )

                            {

                            iSubService.HandleConnectionEvent( EScpRegistrationPending );

                            }

                        else

                            {

                            iSubService.HandleConnectionEvent( EScpRegistrationFailed );

                            }

                        }

                    else

                        {

                        // Connection to VMBx server lost

                        iSubService.HandleConnectionEvent( EScpDeregistered );

                        }

                    }

                }

                break;

            case ENetworkError:

                {

                // Network lost errors may have already been reported

                if( iSubService.LastReportedError() == KErrNone )

                    {

                    // Connection to VMBx server lost

                    iSubService.HandleConnectionEvent( EScpRegistrationFailed );

                    }

                break;

                }

            case EFatalNetworkError:

                {

                // In case of fatal network error forced disable is done to

                // SIP profile.

                PerformInstantForceSipProfileDisable();

                break;

                }

            case EIncorrectSettings:

                {

                iSubService.HandleConnectionEvent( EScpRegistrationFailed );

                }

                break;

            case ENoMemory:

            case ESmsError:

                {

                // :

                // Error handling for VMBx errors

                // In network error case we should change the state to connecting +

                // "service not respondig" error

                SCPLOGSTRING( "Error message from VMBx interface" ) 

                }

                break;

            default:

                {

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

                }

            }

        }

    }

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

// CScpVmbxHandler::SubServiceType

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

//

TCCHSubserviceType CScpVmbxHandler::SubServiceType() const

    {

    SCPLOGSTRING2( "CScpVmbxHandler[0x%x]::SubServiceType", this );

    return ECCHVMBxSub;

    }

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

// CScpVmbxHandler::HandleSipConnectionEvent

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

//

void CScpVmbxHandler::HandleSipConnectionEvent( TUint32 aProfileId,

                                                TScpConnectionEvent aEvent )

    {

    SCPLOGSTRING4( "CScpVmbxHandler[0x%x]::HandleSipConnectionEvent id: %d event: %d",

                   this, aProfileId, aEvent );

    TInt result = KErrNone;

    if( iSubService.SipProfileId() == aProfileId &&

        iSubService.EnableRequestedState() != CScpSubService::EScpNoRequest )

        {

        if ( EScpRoaming == aEvent )

            {

            SCPLOGSTRING( "CScpVmbxHandler - EScpRoaming -> unsubscribe" );

            TRAP( result, UnsubscribeL() );

            SCPLOGSTRING2( "CScpVmbxHandler - unsubscribe error: %d", result );

            }

        if( aEvent == EScpRegistered &&

            iSubService.EnableRequestedState() == CScpSubService::EScpEnabled )

            {

            TRAP( result, SubscribeL() )

            SCPLOGSTRING2( "Subscribe result: %d", result ); 

            if( result == KErrNone )

                {

                // Still connecting the service

                aEvent = EScpNetworkFound;

                }

            else

                {

                if ( iSubService.IsRoaming() && KErrAlreadyExists == result )

                    {

                    // There's still unsubscribe ongoing, we have to wait

                    // ipvoicemailengine event EUnsubscribed and try to 

                    // make subscribe again

                    SCPLOGSTRING( "Resubscribe later" ); 

                    iResubscribe = ETrue;

                    // Still connecting the service

                    aEvent = EScpNetworkFound;

                    }

                else

                    {

                    aEvent = EScpRegistrationFailed;

                    }

                }

            }

        else if( aEvent == EScpDeregistered &&

                 iSubService.EnableRequestedState() == CScpSubService::EScpDisabled ||

                 iSubService.EnableRequestedState() == CScpSubService::EScpRefreshed )

            {

            CancelDisableTimer();

            }

        iSubService.HandleConnectionEvent( aEvent );

        }        

    }

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

// CScpVmbxHandler::SubscribeL

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

//

void CScpVmbxHandler::SubscribeL()

    {

    SCPLOGSTRING2( "CScpVmbxHandler[0x%x]::SubscribeL", this );

    TUint32 sipProfileId = iSubService.SipProfileId();

    CScpProfileHandler& profileHandler = iSubService.ProfileHandler();

    CScpSipConnection* sipConnection = profileHandler.GetSipConnection( sipProfileId );

    if( sipConnection )

        {

        CIpVmbxInterface& vmbxInterface = profileHandler.VmbxInterfaceL( *this );

        // It must be possible to add observers for the vmbx interface

        vmbxInterface.SubscribeL( iSubService.SubServiceId(), 

                                  sipConnection->SipProfile() );

        }

    else

        {

        User::LeaveIfError( KErrNotFound );

        }

    }

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

// CScpVmbxHandler::ForceDisable

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

//

TInt CScpVmbxHandler::ForceVmbxServiceDisable( TAny* aSelf )

    {

    SCPLOGSTRING( "CScpVmbxHandler[0x%x]::ForceVmbxServiceDisable" );

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

    self->CancelDisableTimer();

    self->DeregisterProfile();

    return 1;

    }

//  End of File