/*

* Copyright (c) 2008-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:  Implementation of class CCchUiApiImpl.

*

*/

#include "cchuilogger.h"

#include "cchuiapiimpl.h"

#include "cchuiobserver.h"

#include "cchuispshandler.h"

#include "cchuicchhandler.h"

#include "cchuinotehandler.h"

#include "cchuiclientobserver.h"

#include "cchuiconnectionhandler.h"

const TInt KServiceNameMaxLength = 255;

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

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

// Constructor

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

//

CCchUiApiImpl* CCchUiApiImpl::NewL( CCch& aCch )

    {

    CCchUiApiImpl* cchUiApiImpl = 

        new ( ELeave ) CCchUiApiImpl();

    CleanupStack::PushL( cchUiApiImpl );

    cchUiApiImpl->ConstructL( aCch );

    CleanupStack::Pop( cchUiApiImpl ); 

    return cchUiApiImpl;

    }    

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

// Constructor

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

//

CCchUiApiImpl::CCchUiApiImpl(): 

    iReEnableService( EFalse ),

    iRemovableConnection( KErrNone ),

    iObservedService( 0 )

    {

    }

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

// Constructor

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

//

void CCchUiApiImpl::ConstructL( CCch& aCch )

    {

    iCCHHandler = CCchUiCchHandler::NewL( aCch );    

    iSpsHandler = CCchUiSpsHandler::NewL();

    iNoteController = CCCHUiNoteHandler::NewL( *this );

    iConnectionHandler = CCchUiConnectionHandler::NewL( 

        *iCCHHandler, *iSpsHandler );

    // voip sub service is by default the supported one. 

    // Client can overwrite these

    iAllowedSubServices.AppendL( ECCHVoIPSub );   

    iLastOperationResult = 

          MCchUiObserver::ECchUiClientOperationResultNotSet;

    }

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

// Destructor

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

//

CCchUiApiImpl::~CCchUiApiImpl()

    {    

    if ( iObservedService && iCCHHandler )

        {

        TRAP_IGNORE( iCCHHandler->StopObservingL( 

           iObservedService, *this ) );

        }

    iAllowedNotes.Close();

    iAllowedSubServices.Close();    

    iObservervedServices.Close();

    iObservers.ResetAndDestroy();

    iObservers.Close();

    delete iCCHHandler;

    delete iNoteController;

    delete iSpsHandler;

    delete iConnectionHandler;      

    }

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

// AddObserver.

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

//

void CCchUiApiImpl::AddObserverL( MCchUiObserver& aObserver  )

    {

    CCHUIDEBUG( "CCchUiApiImpl::AddObserver - IN"); 

    // Check if already exists

    TBool alreadyExists = EFalse;

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

        {        

        if ( &aObserver == &iObservers[ i ]->Observer() )

            {

            CCHUIDEBUG( "AddObserver - already exists");           

            alreadyExists = ETrue;

            }

        }

    if ( !alreadyExists )

        {

        CCHUIDEBUG( "AddObserver - add observer"); 

        CCchUiClientObserver* capsulatedObs = 

            CCchUiClientObserver::NewLC( aObserver );

        iObservers.AppendL( capsulatedObs );     

        CleanupStack::Pop( capsulatedObs );

        } 

    CCHUIDEBUG( "CCchUiApiImpl::AddObserver - OUT");

    }

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

// RemoveObserver.

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

//

void CCchUiApiImpl::RemoveObserver( MCchUiObserver& aObserver  )

    {

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

        {

        if ( &aObserver == &iObservers[ i ]->Observer() )

            {           

            delete iObservers[ i ];

            iObservers.Remove( i );

            CCHUIDEBUG( "RemoveObserver - observer removed" );

            }

        }

    iObservers.Compress();

    }

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

// Show dialog.

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

//

void CCchUiApiImpl::ShowDialogL( 

    TUint32 aServiceId, 

    MCchUiObserver::TCchUiDialogType aDialog )

    {

    CCHUIDEBUG2( "CCchUiApiImpl::ShowDialogL - aServiceId: %d", 

        aServiceId );            

    CCHUIDEBUG2( "CCchUiApiImpl::ShowDialogL - aDialog: %d", 

        aDialog );      

    TInt err( KErrNone );

    // Get current connection iap id

    TInt iapId( KErrNone );

    iCCHHandler->GetCurrentConnectionIapIdL(

        aServiceId, ECCHUnknown, iapId, err );

    // Get current service username

    RBuf userName;

    CleanupClosePushL( userName );

    userName.CreateL( KServiceNameLength );

    iCCHHandler->GetUsernameL( aServiceId, userName, err );

    if ( KErrNone == err || KErrNotFound == err )

        {

        CCHUIDEBUG( "ShowDialogL -Launch note" );

        iNoteController->LaunchNoteL( aDialog, aServiceId, iapId, userName );

        }

    else // leave if error code other that KErrNone or KErrNotFound

        {

        CCHUIDEBUG2( "ShowDialogL - leave with err=%d", err );

        User::Leave( err );

        }

    CleanupStack::PopAndDestroy( &userName );

    }

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

// Get currently showing dialog.

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

//

void CCchUiApiImpl::ConfigureVisualizationL( 

    RArray<MCchUiObserver::TCchUiDialogType>& aAllowedNotes,

    RArray<TCCHSubserviceType>& aAllowedSubServices )

    {

    CCHUIDEBUG( "CCchUiApiImpl::ConfigureVisualizationL - IN" );

    CCHUIDEBUG2( "ConfigureVisualizationL - aAllowedNotes count=%d", 

        aAllowedNotes.Count() );

    CCHUIDEBUG2( "ConfigureVisualizationL - aAllowedSubServices count=%d", 

        aAllowedSubServices.Count() );

    TBool subServicesHandled = EFalse;

    TBool dialogsHandled = EFalse;

    // Reset old data

    iAllowedNotes.Reset();

    iAllowedSubServices.Reset();

    if ( KErrNotFound != aAllowedNotes.Find( 

        MCchUiObserver::ECchUiDialogTypeNotSet ) )

        {

        CCHUIDEBUG( "ConfigureVisualizationL - all dialogs are supported" );

        dialogsHandled = ETrue;

        }

    for ( TInt noteIndex = 0 ; 

          noteIndex < aAllowedNotes.Count() && !dialogsHandled ; 

          noteIndex++ )

        {

        CCHUIDEBUG2( "ConfigureVisualizationL - appending allowed note: %d",

            aAllowedNotes[ noteIndex ] );

        iAllowedNotes.AppendL( aAllowedNotes[ noteIndex ] );

        }

    if ( KErrNotFound != aAllowedSubServices.Find( ECCHUnknown ) )

        {

        CCHUIDEBUG( 

            "ConfigureVisualizationL - all sub services are supported" );

        iAllowedSubServices.AppendL( ECCHUnknown );

        subServicesHandled = ETrue;

        }

    for ( TInt servIndex = 0 ; 

          servIndex < aAllowedSubServices.Count() && subServicesHandled ; 

          servIndex++ )

        {

        CCHUIDEBUG2( 

            "ConfigureVisualizationL - appending allowed sub service: %d", 

            aAllowedSubServices[ servIndex ] );

        iAllowedSubServices.AppendL( aAllowedSubServices[ servIndex ] );

        }    

    CCHUIDEBUG( "CCchUiApiImpl::ConfigureVisualizationL - OUT" );

    }

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

// Cancel notes/dialogs.

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

//

void CCchUiApiImpl::CancelNotes()

    {

    CCHUIDEBUG( "CCchUiApiImpl::CancelNotes" );            

    iNoteController->CancelOldNotes();

    }

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

// Manual enable has proceeded

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

//

void CCchUiApiImpl::ManualEnableResultL( 

    TUint aServiceId, 

    TInt aEnableResult )

    {

    CCHUIDEBUG( "CCchUiApiImpl::ManualEnableResultL - IN" );    

    if ( KErrNone == aEnableResult )

        {

        CCHUIDEBUG( "ManualEnableStartedL - start observing service" );

        iCCHHandler->StartObservingL( aServiceId, *this );   

        iObservedService = aServiceId;

        // Check if id already exists in observed services

        TInt err = iObservervedServices.Find( aServiceId ); 

        // Append id only if it is not found.

        if ( KErrNotFound == err )

            {

            CCHUIDEBUG( "ManualEnableStartedL - add to observerd services" );

            iObservervedServices.AppendL( aServiceId );

            }   

        }

    else

        {

        HandleManualEnableErrorL( aServiceId, aEnableResult );

        }

    CCHUIDEBUG( "CCchUiApiImpl::ManualEnableStartedL - OUT" );    

    }    

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

// Manual enable error handling.

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

//

void CCchUiApiImpl::HandleManualEnableErrorL( 

    TUint aServiceId, 

    TInt aEnableResult )

    {

    CCHUIDEBUG( "CCchUiApiImpl::HandleManualEnableErrorL - IN" );    

    CCHUIDEBUG2( "  ---> aEnableResult: %d", aEnableResult );

    MCchUiObserver::TCchUiDialogType dialogType = 

        MCchUiObserver::ECchUiDialogTypeNotSet;

    switch ( aEnableResult )

        {

        case KCCHErrorAccessPointNotDefined:

            {

            dialogType = MCchUiObserver::ECchUiDialogTypeNoConnectionDefined;

            }

            break;

        case KCCHErrorAuthenticationFailed:

            {

            dialogType = MCchUiObserver::ECchUiDialogTypeAuthenticationFailed;    

            }

            break;

        case KCCHErrorInvalidSettings:

            {

            dialogType = MCchUiObserver::ECchUiDialogTypeDefectiveSettings;            

            }

            break;

        case KCCHErrorBandwidthInsufficient:

            {

            dialogType = MCchUiObserver::ECchUiDialogTypeErrorInConnection; 

            }

            break;

        case KCCHErrorInvalidIap:

        case KCCHErrorNetworkLost:

        case KCCHErrorServiceNotResponding:

            {

            dialogType = MCchUiObserver::ECchUiDialogTypeNoConnectionAvailable;

            }

            break;           

        default:

            break;

        }

    // show dialog if dialog type set and dialog allowed

    if ( ( MCchUiObserver::ECchUiDialogTypeNotSet != dialogType ) &&

        ( DialogIsAllowed( dialogType ) ) )

        {

        ShowDialogL( aServiceId, dialogType );

        }

    CCHUIDEBUG( "CCchUiApiImpl::HandleManualEnableErrorL - OUT" );    

    }

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

// Handle dialog completed situation.

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

//

void CCchUiApiImpl::DialogCompletedL( 

    TInt aCompleteCode, 

    TCCHUiNotifierParams aResultParams )

    {

    CCHUIDEBUG( "CCchUiApiImpl::DialogCompletedL - IN");            

    CCHUIDEBUG2( "DialogCompletedL - complete code=%d", aCompleteCode );            

    CCHUIDEBUG2( "DialogCompletedL - dialog mode=%d", 

            aResultParams.iDialogMode  );        

    switch ( aResultParams.iDialogMode )

        {        

        case MCchUiObserver::ECchUiDialogTypeUsernamePasswordFailed:

            {

            // Show username/password query.

            __ASSERT_ALWAYS( DialogIsAllowed( 

                MCchUiObserver::ECchUiDialogTypeAuthenticationFailed ), 

                User::Leave( KErrNotSupported ) );

            CancelNotes();

            ShowDialogL( 

                aResultParams.iServiceId, 

                MCchUiObserver::ECchUiDialogTypeAuthenticationFailed );

            }

            break; 

        case MCchUiObserver::ECchUiDialogTypeAuthenticationFailed:

            {

            DoHandleAuthenticationFailedCompleteL( 

                aCompleteCode, aResultParams );

            }

            break;  

        case MCchUiObserver::ECchUiDialogTypeNoConnectionAvailable:

        case MCchUiObserver::ECchUiDialogTypeNoConnectionDefined:        

            {

            DoHandleNoConnectionsCompleteL( 

                aCompleteCode, aResultParams );

            }

            break;

        case MCchUiObserver::ECchUiDialogTypeDefectiveSettings:

            {

            // Defective settings is permanent type of condition.

            iCCHHandler->DisableL( aResultParams.iServiceId );

            iLastOperationResult = 

                MCchUiObserver::ECchUiClientOperationResultGeneralFailure;

            }

            break;           

        case MCchUiObserver::ECchUiDialogTypeErrorInConnection:

            {

            // Show confirm change connection query

            __ASSERT_ALWAYS( DialogIsAllowed( 

                MCchUiObserver::ECchUiDialogTypeConfirmChangeConnection ), 

                User::Leave( KErrNotSupported ) );

            CancelNotes();

            ShowDialogL( 

                aResultParams.iServiceId, 

                MCchUiObserver::ECchUiDialogTypeConfirmChangeConnection );

            }

            break;

        case MCchUiObserver::ECchUiDialogTypeConfirmChangeConnection:

            {

            DoHandleConfirmChangeConnectionCompleteL( 

                aCompleteCode, aResultParams );

            }

            break;

        case MCchUiObserver::ECchUiDialogTypeChangeConnection:

            {

            DoHandleChangeConnectionCompleteL( 

                aCompleteCode, aResultParams );

            }

            break;            

        default:

            CCHUIDEBUG( "DialogCompletedL - default switch case" );  

            break;    

        }    

    CCHUIDEBUG( "CCchUiApiImpl::DialogCompletedL - OUT" );  

    }

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

// Checks if specific note is allowed

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

//

TBool CCchUiApiImpl::DialogIsAllowed( 

    MCchUiObserver::TCchUiDialogType aDialog )

    {

    CCHUIDEBUG( "CCchUiApiImpl::DialogIsAllowed");

    CCHUIDEBUG2( "CCchUiApiImpl::DialogIsAllowed - allowed notes count=%d", 

        iAllowedNotes.Count() );

    CCHUIDEBUG2( "CCchUiApiImpl::DialogIsAllowed - aDialog find result=%d", 

        iAllowedNotes.Find( aDialog ) );

    TBool ret = EFalse;

    if ( !iAllowedNotes.Count() ) return ETrue; // not configured, all allowed

    else if ( KErrNotFound != iAllowedNotes.Find( 

        MCchUiObserver::ECchUiDialogTypeNotSet ) ) return ETrue;

    else if ( KErrNotFound != iAllowedNotes.Find( aDialog ) ) return ETrue;

    CCHUIDEBUG2( "DialogIsAllowed - return: %d", ret );

    return ret;            

    }

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

// Checks if specific sub service  is allowed

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

//

TBool CCchUiApiImpl::SubServiceIsAllowed( TCCHSubserviceType aSubService )

    {

    CCHUIDEBUG( "CCchUiApiImpl::SubServiceIsAllowed");            

    CCHUIDEBUG2( "SubServiceIsAllowed - allowed subserv=%d", 

        iAllowedSubServices.Count() );

    CCHUIDEBUG2( "SubServiceIsAllowed - aSubService find=%d", 

        iAllowedSubServices.Find( aSubService ) );

    CCHUIDEBUG2( "SubServiceIsAllowed - all supported=%d", 

        iAllowedSubServices.Find( ECCHUnknown ) );

    // If subservice type is ECCHUnknown -> subservice is allowed, other

    // types are checked from array.

    TBool allowed = EFalse;

    TInt result = iAllowedSubServices.Find( aSubService );

    if ( ECCHUnknown == aSubService )

        {

        allowed = ETrue;

        }

    else if ( KErrNotFound != result )

        {

        allowed = ETrue;

        }

    else

        {

        allowed = EFalse;

        }

    CCHUIDEBUG2( "SubServiceIsAllowed - return: %d", allowed );

    return allowed;

    }

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

// Checks subservice state is allowed for showing dialogs.

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

//

TBool CCchUiApiImpl::StateIsAllowed( const TCCHSubserviceState aState )

    {

    CCHUIDEBUG( "CCchUiApiImpl::StateIsAllowed");  

    TBool allowed( EFalse );

    switch ( aState )

        {

        case ECCHUninitialized:

        case ECCHDisabled:

        case ECCHDisconnecting:

            {

            CCHUIDEBUG( "CCchUiApiImpl::StateIsAllowed: Not allowed");

            }

            break;           

        case ECCHConnecting:

        case ECCHEnabled:

            {

            CCHUIDEBUG( "CCchUiApiImpl::StateIsAllowed: Allowed");

            allowed = ETrue;

            }

            break;

        default:

            CCHUIDEBUG( "CCchUiApiImpl::StateIsAllowed: DEFAULT case");

            break;

        }

    return allowed;

    }