/*

* Copyright (c) 2004 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:  Connection mode handler implementation.

*

*/

// INCLUDE FILES

#include <E32Std.h>

#include "CCnUiConnModeHandler.h"

#include "CnUiPanics.h"

// ================= GLOBAL FUNCTIONS =======================

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

// CreateConnModeHandlerL()

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

//

GLREF_C MCnUiConnModeHandler* CreateConnModeHandlerL()

    {

    return CCnUiConnModeHandler::NewL();

    }

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

// Two-phased constructor.

CCnUiConnModeHandler* CCnUiConnModeHandler::NewL()

    {

    CCnUiConnModeHandler* self = new ( ELeave ) CCnUiConnModeHandler;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CCnUiConnModeHandler::~CCnUiConnModeHandler()

    {

    //Cancel any outstanding request

    CancelRegisteringAsSSClient();

    CancelConnectionModeNotify();

    }

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

// might leave.

//

CCnUiConnModeHandler::CCnUiConnModeHandler()

    {

    }

// Symbian OS default constructor can leave.

void CCnUiConnModeHandler::ConstructL()

    {

    }

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

// CCnUiConnModeHandler::SendUserSelectionL()

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

//

void CCnUiConnModeHandler::SendUserSelectionL( TIMPSUserConnectionSelection aUserSelection,

                                               TIMPSConnectionClient aClient )

    {

    TIMPSConnectionModeEvent event = EIMPSCMEUnknown;

    switch ( aUserSelection )

        {

        case EUserLevelLogin:

            {

            event = EIMPSCMEUserLevelLogin;

            break;

            }

        case EUserLevelLogout:

            {

            event = EIMPSCMEUserLevelLogout;

            break;

            }

        case EUserLevelAAConnectionStart:

            {

            event = EIMPSCMEUserLevelAAConnectionStart;

            break;

            }

        default:

            {

            User::Leave( KErrArgument );

            break;

            }

        }

    CCnUiGroupChannel* loginLogoutChannel =

        CCnUiGroupChannel::NewLC( aClient,

                                  ECnUiLoginLogoutEventChannel );

    loginLogoutChannel->WriteL( event );

    CleanupStack::PopAndDestroy( loginLogoutChannel ); //loginLogoutChannel

    }

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

// CCnUiConnModeHandler::RegisterAsSignificantSchedulingClientL()

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

//

TInt CCnUiConnModeHandler::RegisterAsSignificantSchedulingClientL( TIMPSConnectionClient aClient )

    {

    if ( iSSReqistration )

        {

        return KErrInUse;

        }

    iSSReqistration = CCnUiGroupChannel::NewL( aClient,

                                               ECnUiSSClientReqistrationChannel );

    iSSReqistration->SignalL();

    return KErrNone;

    }

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

// CCnUiConnModeHandler::CancelRegisteringAsSSClient()

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

//

void CCnUiConnModeHandler::CancelRegisteringAsSSClient()

    {

    if ( iSSReqistration )

        {

        iSSReqistration->CancelSignal();

        delete iSSReqistration;

        iSSReqistration = NULL;

        }

    }

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

// CCnUiConnModeHandler::ConnectionModeL()

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

//

TIMPSConnectionModeEvent CCnUiConnModeHandler::ConnectionModeL(

    TIMPSConnectionClient aClient,

    TIMPSConnectionModeEvent aModeEventCateqory )

    {

    TInt cateqorizedEvent = EIMPSCMEUnknown;

    if ( aModeEventCateqory == EIMPSCMEUserLevelSelectionEventGroup )

        {

        //client wants the login logout event value

        //retrieve value from channel & verify its range

        CCnUiGroupChannel* loginLogoutChannel =

            CCnUiGroupChannel::NewLC( aClient,

                                      ECnUiLoginLogoutEventChannel );

        TInt lastEventValue = KErrNotFound;

        loginLogoutChannel->Read( lastEventValue );

        CleanupStack::PopAndDestroy( loginLogoutChannel ); //loginLogoutChannel

        if ( LoginLogoutModeCategoryEvent( lastEventValue ) )

            {

            cateqorizedEvent = lastEventValue;

            }

        }

    else if ( aModeEventCateqory == EIMPSCMESSClientEventGroup )

        {

        //client wants the SS Client Start/Stop event

        //retrieve the client registration count channel

        CCnUiGroupChannel* reqistrationChannel =

            CCnUiGroupChannel::NewLC( aClient,

                                      ECnUiSSClientReqistrationChannel );

        TInt clientReqistrationCount = KErrNotFound;

        reqistrationChannel->Read( clientReqistrationCount );

        CleanupStack::PopAndDestroy( reqistrationChannel ); //reqistrationChannel

        if ( clientReqistrationCount == 0 ) //0 client currently registered ==> last stopped

            {

            cateqorizedEvent = EIMPSCMELastSSClientStop;

            }

        else if ( clientReqistrationCount > 0 ) //more than 0 currently registered clients

            {

            cateqorizedEvent = EIMPSCMEFirstSSClientStart;

            }

        }

    return static_cast<TIMPSConnectionModeEvent> ( cateqorizedEvent );

    }

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

// CCnUiConnModeHandler::NotifyConnectionModeChangesL()

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

//

void CCnUiConnModeHandler::NotifyConnectionModeChangesL( MCnUiConnModeObserver* aObserver,

                                                         TIMPSConnectionClient aClientToNotify )

    {

    __ASSERT_ALWAYS( !iConnModeObserver, User::Leave( KErrInUse ) );

    __ASSERT_ALWAYS( aObserver, User::Leave( KErrArgument ) );

    TRAPD( err, DoStartNotifyL( aClientToNotify ) );

    if ( err != KErrNone )

        {

        CancelConnectionModeNotify();

        User::Leave( err );

        }

    //store observer information

    iConnModeObserver = aObserver;

    iObserverClient = aClientToNotify;

    }

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

// CCnUiConnModeHandler::CancelConnectionModeNotify()

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

//

void CCnUiConnModeHandler::CancelConnectionModeNotify()

    {

    delete iLoginLogoutEventChannelListener;

    delete iSSReqistrationChannelListener;

    iLoginLogoutEventChannelListener = NULL;

    iSSReqistrationChannelListener = NULL;

    iConnModeObserver = NULL;

    iSSClientCountPrev = KErrNotFound;

    }

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

// CCnUiConnModeHandler::HandleNotifyL()

// from MCnUiGroupChannelListener

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

//

void CCnUiConnModeHandler::HandleChannelMsg( TInt aGroupId,

                                             TGCChannelID aChannelId,

                                             TInt aChannelMsg )

    {

    if ( iObserverClient != aGroupId )

        {

        return;

        }

    if ( aChannelId == ECnUiLoginLogoutEventChannel )

        {

        //login/logout related event

        TIMPSConnectionModeEvent event = static_cast<TIMPSConnectionModeEvent>( aChannelMsg );

        if ( LoginLogoutModeCategoryEvent( event ) )

            {

            iConnModeObserver->HandleConnModeChange( iObserverClient, event ) ;

            }

        }

    else if ( aChannelId == ECnUiSSClientReqistrationChannel )

        {

        //SSClient start/stop event - actually a signal count

        //If client count increased from zero to 1 ==> first client started

        if ( ( iSSClientCountPrev == 0 ) && ( aChannelMsg == 1 ) )

            {

            iConnModeObserver->HandleConnModeChange( iObserverClient, EIMPSCMEFirstSSClientStart );

            iSSClientCountPrev = aChannelMsg;

            }

        //If client count decreased to zero ==> last client stopped

        else if ( ( iSSClientCountPrev > 0 ) && ( aChannelMsg == 0 ) )

            {

            iConnModeObserver->HandleConnModeChange( iObserverClient, EIMPSCMELastSSClientStop );

            iSSClientCountPrev = aChannelMsg;

            }

        }

    }

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

// CCnUiConnModeHandler::DoStartNotifyL()

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

//

void CCnUiConnModeHandler::DoStartNotifyL( TIMPSConnectionClient aClientToNotify )

    {

    //start the channel notifier for login/logout related events

    iLoginLogoutEventChannelListener = CCnUiGroupChannel::NewL( aClientToNotify,

                                                                ECnUiLoginLogoutEventChannel );

    iLoginLogoutEventChannelListener->ListenL( this );

    //start the channel notifier for client start/stops

    iSSReqistrationChannelListener = CCnUiGroupChannel::NewL( aClientToNotify,

                                                              ECnUiSSClientReqistrationChannel );

    iSSReqistrationChannelListener->ListenL( this );

    TInt clientReqistrationCount = KErrNotFound;

    iSSReqistrationChannelListener->Read( clientReqistrationCount );

    //if there is a positive registration count, use it.

    //Else default pre count to 0

    if ( clientReqistrationCount >= 0 )

        {

        iSSClientCountPrev = clientReqistrationCount;

        }

    else

        {

        iSSClientCountPrev = 0;

        }

    }

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

// CCnUiConnModeHandler::LoginLogoutModeCategoryEvent()

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

//

TBool CCnUiConnModeHandler::LoginLogoutModeCategoryEvent( TInt aEvent )

    {

    switch ( aEvent )

        {

            //FLOW TROUGH

        case EIMPSCMEUserLevelLogout:

        case EIMPSCMEUserLevelLogin:

        case EIMPSCMEUserLevelAAConnectionStart:

            {

            //known events

            return ETrue;

            // no break needed because of return

            }

        default:

            {

            //unknown event

            break;

            }

        }

    return EFalse;

    }

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

// CCnUiConnModeHandler::SSClientStartStopEvent()

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

//

TBool CCnUiConnModeHandler::SSClientStartStopCategoryEvent( TInt aEvent )

    {

    switch ( aEvent )

        {

            //FLOW TROUGH

        case EIMPSCMEFirstSSClientStart:

        case EIMPSCMELastSSClientStop:

            {

            //known events

            return ETrue;

            // no break needed because of return

            }

        default:

            {

            //unknown event for this category

            break;

            }

        }

    return EFalse;

    }

//  End of File