/*

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

*

*/

// INCLUDE FILES

#include <cchclientserver.h>

#include <spnotifychange.h>

#include "cchservicehandler.h"

#include "cchserverbase.h"

#include "cchspshandler.h"

#include "cchlogger.h"

#include "cchpluginhandler.h"

#include "cchuihandler.h"

#include "cchconnmonhandler.h"

#include "cchwlanextension.h"

#include "cchcommdbwatcher.h"

#include "cchcommdbwatcherobserver.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES

// None

// CONSTANTS

const TInt KConnectionRecoveryMaxTries = 5;

const TInt KCCHFirstRecovery    = 15000000;

const TInt KCCHSecondRecovery   = 15000000;

const TInt KCCHThirdRecovery    = 30000000;

const TInt KCCHFourthRecovery   = 60000000;

const TInt KCCHFifthRecovery    = 60000000;

const TInt KCCHPluginUnloadTimeout = 5000000;

const TInt KCCHHandleNotifyDelay = 1000000;

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None.

// ============================= LOCAL FUNCTIONS =============================

// ============================ MEMBER FUNCTIONS =============================

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

// CCCHServiceHandler::CCCHServiceHandler

// C++ default constructor can NOT contain any code, that might leave.

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

//

CCCHServiceHandler::CCCHServiceHandler( CCCHServerBase& aServer ) :

    iServer( aServer ),

    iConnectionRecoveryTry( 0 ),

    iCancelNotify( ETrue ) 

    {

    // No implementation required

    }

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

// CCCHServiceHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCCHServiceHandler::ConstructL()

    {

    iNotifier = CSPNotifyChange::NewL( *this );

    iCchUIHandler = CCchUIHandler::NewL( iServer, *this );

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

    iCommDbWatcher = CCCHCommDbWatcher::NewL( *this );

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

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

    iRecoveryInterval.Append( KCCHFirstRecovery );

    iRecoveryInterval.Append( KCCHSecondRecovery );

    iRecoveryInterval.Append( KCCHThirdRecovery );

    iRecoveryInterval.Append( KCCHFourthRecovery );

    iRecoveryInterval.Append( KCCHFifthRecovery );

    iWlanExtension = CCchWlanExtension::NewL( );

    }

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

// CCCHServiceHandler::NewL

// Two-phased constructor.

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

//

CCCHServiceHandler* CCCHServiceHandler::NewL( CCCHServerBase& aServer )

    {

    CCCHServiceHandler* self = CCCHServiceHandler::NewLC( aServer );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCCHServiceHandler::NewLC

// Two-phased constructor.

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

//

CCCHServiceHandler* CCCHServiceHandler::NewLC( CCCHServerBase& aServer )

    {

    CCCHServiceHandler* self = new (ELeave) CCCHServiceHandler( aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CCCHServiceHandler::~CCCHServiceHandler()

    {

    if ( iCchUIHandler )

        {

        iCchUIHandler->Destroy();

        }

    delete iWlanExtension;

    delete iConnectionRecoveryTimer;

    delete iPluginUnloadTimer;

    delete iHandleNotifyDelayTimer;

    delete iCommDbWatcher;

    if( iNotifier )

        {

        iNotifier->Cancel();

        delete iNotifier;

        iNotifier = NULL;    

        }

    iServiceIds.Close();

    iServer.PluginHandler().RemoveServiceNotifier( this );

    iServices.ResetAndDestroy();

    iServicesInRecovery.Close();

    iRecoveryInterval.Close();

    }

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

// CCCHServiceHandler::InitServiceHandlerL

// (other items were commented in a header).

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

//

void CCCHServiceHandler::InitServiceHandlerL()

    {

    CCHLOGSTRING2( "CCCHServiceHandler::InitServiceHandlerL [0x%x]: IN",this );

    RArray<TUint> serviceIds;

    CleanupClosePushL( serviceIds );

    iServer.SPSHandler().GetServiceIdsL( serviceIds );

    for ( TInt i( 0 ); i < serviceIds.Count(); i++ )

        {        

        if ( KErrNotFound == FindService( serviceIds[ i ] ) )

            {

            TCCHService service;

            TRAPD( error, iServer.SPSHandler().GetServiceInfoL( 

                serviceIds[ i ], service ) );

            if ( KErrNone == error )

                {

                AddServiceL( service );    

                }                    

            }

        }

    CleanupStack::PopAndDestroy( &serviceIds );

    // Subscribe to service change notifies    

    EnableNotifyChange();

    CCHLOGSTRING( "CCCHServiceHandler::InitServiceHandlerL: OUT" );

    }

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

// CCCHServiceHandler::AddServiceL

// (other items were commented in a header).

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

//

void CCCHServiceHandler::AddServiceL( TCCHService& aService )

    {

    CCHLOGSTRING( "CCCHServiceHandler::AddServiceL: IN" );

    CCCHServiceInfo* cchServiceInfo = CCCHServiceInfo::NewLC( iServer );

    cchServiceInfo->SetServiceId( aService.iServiceId );

    cchServiceInfo->SetName( aService.iServiceName );

    CCHLOGSTRING2( "CCCHServiceHandler::AddServiceL: adding service with %d subservices",aService.iSubservices.Count() );

    for ( TInt i( 0 ); i < aService.iSubservices.Count(); i++ )

        {

        cchServiceInfo->AddSubserviceL( aService.iSubservices[ i ] );

        }

    CleanupStack::Pop( cchServiceInfo );

    iServices.Append( cchServiceInfo );

    CCHLOGSTRING( "CCCHServiceHandler::AddServiceL: OUT" );

    }

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

// CCCHServiceHandler::UpdateL

// (other items were commented in a header).

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

//

void CCCHServiceHandler::UpdateL( TBool aReadSettingTable )

    {

    CCHLOGSTRING( "CCCHServiceHandler::UpdateL: IN" );

    // Read settings from service table

    if ( aReadSettingTable )

        {

        RArray<TUint> serviceIds;

        CleanupClosePushL( serviceIds );

        TInt index( KErrNotFound );

        iServer.SPSHandler().GetServiceIdsL( serviceIds );

        for ( TInt i( 0 ); i < serviceIds.Count(); i++ )

            {        

            index = FindService( serviceIds[ i ] );

            if ( KErrNotFound != index )

                {

                iServices[ index ]->UpdateL( ETrue );

                }

            else

                {

                CCHLOGSTRING2

                    ( "CCCHSeviceHandler::UpdateL: \

                        New service found: ServiceId %d", serviceIds[ i ] );

                TCCHService service;

                TRAPD( error, iServer.SPSHandler().GetServiceInfoL( 

                    serviceIds[ i ], service ) );

                if ( KErrNone == error )

                    {

                    AddServiceL( service );

                    }                

                }

            }

        if ( serviceIds.Count() < iServices.Count() )

            {

            // Remove service's which does not exist anymore            

            for ( TInt i( 0 ); i < iServices.Count(); i++ )

                {            

                if ( KErrNotFound == serviceIds.Find( 

                    iServices[ i ]->GetServiceId( ) ) )

                    {

                    CCHLOGSTRING2

                        ( "CCCHSeviceHandler::UpdateL: \

                        service removed: ServiceId %d", 

                        iServices[ i ]->GetServiceId() );

                    delete iServices[ i ];

                    iServices.Remove( i );

                    i--;

                    StartPluginUnloadTimer( );

                    }

                }

            }

        CleanupStack::PopAndDestroy( &serviceIds );

        }

    else

        {

        for ( TInt i( 0 ); i < iServices.Count(); i++ )

            {

            iServices[ i ]->UpdateL();

            }    

        }

    CCHLOGSTRING( "CCCHServiceHandler::UpdateL: OUT" );

    }

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

// CCCHServiceHandler::IsStartupFlagSet

// (other items were commented in a header).

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

//

TBool CCCHServiceHandler::IsStartupFlagSet() const

    {

    TBool ret( EFalse );

    for ( TInt i( 0 ); i < iServices.Count() && !ret; i++ )

        {

        ret = iServices[ i ]->StartupFlagSet();

        }

    CCHLOGSTRING2( "CCCHServiceHandler::IsStartupFlagSet: %d", ret );

    return ret;

    }

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

// CCCHServiceHandler::IsRecoveryNeeded

// (other items were commented in a header).

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

//

TBool CCCHServiceHandler::IsRecoveryNeeded( 

                               const TCCHSubserviceState aState, 

                               TInt aError )

    {

    TBool recover( EFalse );

    CCHLOGSTRING( "CCCHServiceHandler::IsRecoveryNeeded: IN" );

    if( !iServer.FeatureManager().OfflineMode() &&

        ECCHConnecting == aState && ( 

        KCCHErrorNetworkLost == aError || 

        KCCHErrorServiceNotResponding == aError ) &&

        !iConnectionRecoveryTimer->IsActive() )

        {

        recover = ETrue;            

        }

    CCHLOGSTRING2( "CCCHServiceHandler::IsRecoveryNeeded: OUT, value=%d", recover );

    return recover;

    }

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

// CCCHServiceHandler::StateChangedL

// (other items were commented in a header).

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

//

void CCCHServiceHandler::StateChangedL( const TUint aServiceId,

                                        const TCCHSubserviceType aType,

                                        const TCCHSubserviceState aState,

                                        const TInt aError )

    {

    CCHLOGSTRING( "CCCHServiceHandler::StateChanged: IN" );

    CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service id;        %d",aServiceId );

    CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service type;      %d",aType );

    CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service new state; %d",aState );

    CCHLOGSTRING2( "CCCHServiceHandler::StateChanged: service error;     %d",aError );

    TInt index( FindService( aServiceId ) );

    if ( KErrNotFound != index )

        {

        iServices[ index ]->SetErrorL( aType, aError );

        iServices[ index ]->SetStateL( aType, aState );

        //toggle voip indicator & emergency note if needed

        if( ECCHVoIPSub == aType )

            {

            iCchUIHandler->UpdateUI( );

            }

        // Check for possible first usage of GPRS (roaming cost warning)

        TServiceConnectionInfo serviceConnInfo( aServiceId, aType, 0, 0 );

        GetConnectionInfo( serviceConnInfo );

        if ( serviceConnInfo.iIapId && ECCHEnabled == aState )

            {

            if( !iCommDbWatcher->IsWlanApL( serviceConnInfo.iIapId ) )

                {                

                iCchUIHandler->CheckGprsFirstUsageL();

                }

            }

        //unload useless plugins    

        if( ECCHDisabled == aState )

            {

            StartPluginUnloadTimer( );

            }

        //start fast recovery if not started

        else if( IsRecoveryNeeded( aState, aError ) )

            {

            CCHLOGSTRING( "CCCHServiceHandler::StateChangedL network lost, starting recovery" );

            iServicesInRecovery.Append( TServiceSelection( aServiceId, aType ) );

            StartConnectionRecoveryTimer( CCCHServiceHandler::ConnectionRecoveryEvent );                

            }

        //stop fast recovery

        if( ECCHConnecting != aState && 

                KErrNone == aError &&

                0 < iServicesInRecovery.Count() )

            {

            CCHLOGSTRING( "CCCHServiceHandler::StateChangedL checking if recovery is still needed" );

            TInt idx = iServicesInRecovery.Find( TServiceSelection( aServiceId, aType ) );

            if( KErrNotFound != idx )

                {

                CCHLOGSTRING( "CCCHServiceHandler::StateChangedL this service has recovered, recovery still on..." );

                iServicesInRecovery.Remove( idx );

                }

            if( 0 == iServicesInRecovery.Count() )

                {

                CCHLOGSTRING( "CCCHServiceHandler::StateChangedL all services recovered, stopping recovery" );

                CancelConnectionRecoveryTimer();

                }

            }

        if ( ECCHConnecting != aState || 

            ECCHConnecting == aState && KErrNone != aError )

            {

            // reset startup counter

            TBool startupFlag( EFalse );

            iServer.SPSHandler().LoadAtStartUpL( aServiceId, aType, startupFlag );

            if ( startupFlag )

                {

                iServer.ResetStartupCounterL();

                }

            }

        }

    else

        {

        User::Leave( index );

        }

    CCHLOGSTRING( "CCCHServiceHandler::StateChanged: OUT" );

    }

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

// CCCHServiceHandler::StartConnectionRecoveryTimer

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

//

void CCCHServiceHandler::StartConnectionRecoveryTimer( TInt (*aFunction)(TAny* aPtr) )

    {

    CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::StartConnectionRecoveryTimer; IN", this );

    CancelConnectionRecoveryTimer();

    if( !iConnectionRecoveryTimer->IsActive() )

        {

        iConnectionRecoveryTry = 0;

        iConnectionRecoveryTimer->Start( iRecoveryInterval[ iConnectionRecoveryTry ] , 

                              0, 

                              TCallBack( aFunction, this ) );

        CCHLOGSTRING( "CCCHServiceHandler::StartConnectionRecoveryTimer; recovery timer started");

        }

    CCHLOGSTRING( "CCCHServiceHandler::StartConnectionRecoveryTimer; OUT");

    }

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

// CCCHServiceHandler::CancelConnectionRecoveryTimer

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

//

void CCCHServiceHandler::CancelConnectionRecoveryTimer()

    {

    CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::CancelConnectionRecoveryTimer; IN", this );

    if( iConnectionRecoveryTimer->IsActive() )

        {

        iConnectionRecoveryTimer->Cancel();

        }

    CCHLOGSTRING( "CCCHServiceHandler::CancelConnectionRecoveryTimer; OUT" );        

    }

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

// CCCHServiceHandler::ConnectionRecoveryEvent

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

//

TInt CCCHServiceHandler::ConnectionRecoveryEvent( TAny* aSelf )

    {

    CCHLOGSTRING( "CCCHServiceHandler::ConnectionRecoveryEvent; IN" );

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

    self->HandleConnectionRecovery();

    CCHLOGSTRING( "CCCHServiceHandler::ConnectionRecoveryEvent; OUT" );

    return 0;

    }

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

// CCCHServiceHandler::HandleConnectionRecovery

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

//

void CCCHServiceHandler::HandleConnectionRecovery()

    {

    CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::HandleConnectionRecovery IN",

                   this );

    iConnectionRecoveryTry++;

    CCHLOGSTRING2( "CCCHServiceHandler::HandleConnectionRecovery; recovery try:%d",iConnectionRecoveryTry );

    iServer.ConnMonHandler().ScanNetworks( ETrue );    

    CancelConnectionRecoveryTimer();

    if( KConnectionRecoveryMaxTries > iConnectionRecoveryTry )

        {

        CCHLOGSTRING( "CCCHServiceHandler::HandleConnectionRecovery; recovery continues" );

        iConnectionRecoveryTimer->Start( iRecoveryInterval[ iConnectionRecoveryTry ], 

                              0,

                              TCallBack( CCCHServiceHandler::ConnectionRecoveryEvent, this ) );

        }

    else

        {

        CCHLOGSTRING( "CCCHServiceHandler::HandleConnectionRecovery; max tries reached, recovery canceled" );

        }                   

    CCHLOGSTRING( "CCCHServiceHandler::HandleConnectionRecovery OUT" );

    }

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

// CCCHServiceHandler::StartPluginUnloadTimer

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

//

void CCCHServiceHandler::StartPluginUnloadTimer( )

    {

    CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::StartPluginUnloadTimer; IN", this );

    CancelPluginUnloadTimer();

    if( !iPluginUnloadTimer->IsActive() )

        {

        iPluginUnloadTimer->Start( KCCHPluginUnloadTimeout , 

                              0, 

                              TCallBack( CCCHServiceHandler::PluginUnloadEvent, this ) );

        CCHLOGSTRING( "CCCHServiceHandler::StartPluginUnloadTimer; plugin unload timer started");

        }

    CCHLOGSTRING( "CCCHServiceHandler::StartPluginUnloadTimer; OUT");

    }

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

// CCCHServiceHandler::CancelPluginUnloadTimer

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

//

void CCCHServiceHandler::CancelPluginUnloadTimer()

    {

    CCHLOGSTRING2( "CCCHServiceHandler[0x%x]::CancelPluginUnloadTimer; IN", this );

    if( iPluginUnloadTimer->IsActive() )

        {

        iPluginUnloadTimer->Cancel();

        }

    CCHLOGSTRING( "CCCHServiceHandler::CancelPluginUnloadTimer; OUT" );        

    }