/*

* 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 UI implementation.

*

*/

// INCLUDE FILES

#include <E32std.h>

#include <CIMPSSAPSettings.h>

#include <CPEngNWSessionSlotID2.h>

#include <CPEngNWSessionSlotManager2.h>

#include <PEngPresenceEngineConsts2.h>

#include <CPEngNWSessionSlot2.h>

#include <sysutil.h>

#include "CIMPSPresenceConnectionUiImp.h"

#include "MCnUiConnectionHandler.h"

#include "MCnUiSignaller.h"

#include "CCnUiUiControlContext.h"

#include "CCnUiConnModeRewaker.h"

#include "CnUiErrors.h"

#include "IMPSCommonUiDebugPrint.h"

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

// Two-phased constructor.

CIMPSPresenceConnectionUiImp* CIMPSPresenceConnectionUiImp::NewL(

    TIMPSConnectionClient aClient,

    CIMPSSAPSettingsStore* aSapStore )

    {

    CIMPSPresenceConnectionUiImp* self =

        new ( ELeave ) CIMPSPresenceConnectionUiImp( aClient, aSapStore );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); //self

    return self;

    }

// Destructor

CIMPSPresenceConnectionUiImp::~CIMPSPresenceConnectionUiImp()

    {

    delete iConnModeRewaker;

    delete iConnHandler;

    }

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

// might leave.

//

CIMPSPresenceConnectionUiImp::CIMPSPresenceConnectionUiImp( TIMPSConnectionClient aClient,

                                                            CIMPSSAPSettingsStore* aSapStore )

        : iSapStoreProxy( aSapStore ), iClient( aClient )

    {

    }

// Symbian OS default constructor can leave.

void CIMPSPresenceConnectionUiImp::ConstructL()

    {

    // set the client information to the TLS

    User::LeaveIfError( Dll::SetTls( reinterpret_cast<TAny*>( iClient ) ) );

    iConnHandler = CreateConnHandlerL( iSapStoreProxy );

    iConnModeRewaker = CCnUiConnModeRewaker::NewL();

    ReStoreNWSessionOwnershipL();

    }

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

// CIMPSPresenceConnectionUiImp::LoginL()

//

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

//

TInt CIMPSPresenceConnectionUiImp::LoginL( TIMPSConnectionClient aClient,

                                           TIMPSLoginType aLoginType,

                                           CPEngNWSessionSlotID2& aNWSessionSlotID,

                                           MIMPSConnProcessObserver* aObserver,

                                           CIMPSSAPSettings* aSap /*= NULL*/,

                                           TBool aLastLoginSap /*= EFalse*/ )

    {

    if ( LoggedInL( aClient ) )

        {

        // it seems we are already logged in

        return KErrAlreadyExists;

        }

    // Check disk space

    if ( SysUtil::FFSSpaceBelowCriticalLevelL( NULL, 0 ) )

        {

        // Don't show any own notes here

        User::Leave( KErrDiskFull );

        }

    iConnModeRewaker->SuspendLC();

    // add two extra param if user want to login to last server only

    CCnUiUiControlContext* uiCC = CCnUiUiControlContext::NewLC( aClient,

                                                                iSapStoreProxy,

                                                                *iConnModeRewaker,

                                                                *iConnHandler,

                                                                aObserver );

    TInt retStatus = uiCC->DoLoginL( aLoginType, aNWSessionSlotID, aSap, aLastLoginSap );

    CleanupStack::PopAndDestroy( 2 ); //uiCC, Resume ReWake

    return MapToUiLoginReturnStatus( retStatus );

    }

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

// CIMPSPresenceConnectionUiImp::LogoutL()

//

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

//

TInt CIMPSPresenceConnectionUiImp::LogoutL( const CPEngNWSessionSlotID2& aNWSessionSlotID,

                                            MIMPSConnProcessObserver* aObserver )

    {

    TIMPSConnectionClient client;

    if ( 0 == aNWSessionSlotID.AppId().Compare( KPEngAppIdIM ) )

        {

        client = EIMPSConnClientIM;

        }

    else

        {

        client = EIMPSConnClientPEC;

        }

    //if client isn't logged in, nothing to do..

    if ( !iConnHandler->TheClientLoggedInL( client ) )

        {

        return KErrNone;

        }

    iConnModeRewaker->SuspendLC();

    CCnUiUiControlContext* uiCC = CCnUiUiControlContext::NewLC( client,

                                                                iSapStoreProxy,

                                                                *iConnModeRewaker,

                                                                *iConnHandler,

                                                                aObserver );

    uiCC->DoLogoutL( aNWSessionSlotID );

    CleanupStack::PopAndDestroy( 2 ); //uiCC, Resume ReWake

    return KErrNone;

    }

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

// CIMPSPresenceConnectionUiImp::HandleApplicationExitL()

//

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

//

TInt CIMPSPresenceConnectionUiImp::HandleApplicationExitL(

    TIMPSConnectionClient aClient,

    TIMPSExitType aExitType,

    const CPEngNWSessionSlotID2& aNWSessionSlotID,

    MIMPSConnProcessObserver* aObserver )

    {

    //if client isn't logged in, nothing to do..

    if ( !iConnHandler->TheClientLoggedInL( aClient ) )

        {

        return KErrNone;

        }

    //logged in, handle as normal commands

    if ( aExitType == EIMPSLeaveSessionOpenExit )

        {

        // we are supposed to store the ownership here

        StoreNWSessionOwnershipL( aNWSessionSlotID );

        return KErrNone;

        }

    iConnModeRewaker->SuspendLC();

    CCnUiUiControlContext* uiCC = CCnUiUiControlContext::NewLC( aClient,

                                                                iSapStoreProxy,

                                                                *iConnModeRewaker,

                                                                *iConnHandler,

                                                                aObserver );

    TInt retStatus = uiCC->DoHandleApplicationExitL( aExitType, aNWSessionSlotID );

    CleanupStack::PopAndDestroy( 2 ); //uiCC, Resume ReWake

    if ( retStatus == KErrCancel )

        {

        // query was shown, and user selected to leave the session open

        StoreNWSessionOwnershipL( aNWSessionSlotID );

        }

    return retStatus;

    }

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

// CIMPSPresenceConnectionUiImp::GetActiveNWSessionSlotIDL()

//

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

//

CPEngNWSessionSlotID2* CIMPSPresenceConnectionUiImp::GetActiveNWSessionSlotIDL(

    TIMPSConnectionClient aClient )

    {

    CPEngNWSessionSlotManager2* slotManager = CPEngNWSessionSlotManager2::NewLC();

    CPEngNWSessionSlotID2* pattern = CPEngNWSessionSlotID2::NewLC();

    pattern->SetServiceAddressMatchAnyL();

    pattern->SetUserIdMatchAnyL();

    if ( aClient == EIMPSConnClientPEC )

        {

        pattern->SetAppIdL( KPEngAppIdPEC );

        }

    else

        {

        pattern->SetAppIdL( KPEngAppIdIM );

        }

    RPointerArray< CPEngNWSessionSlotID2 > array;

    TInt error( slotManager->GetNWSessionSlots( array,

                                                *pattern,

                                                EPEngNWPresenceSessionOpen ) );

    if ( error != KErrNone )

        {

        array.ResetAndDestroy();

        User::Leave( error );

        }

    CleanupStack::PopAndDestroy( 2, slotManager ); // pattern, slotManager

    CleanupStack::PushL( TCleanupItem( DestroyCloseModelArray, &array ) );

    CPEngNWSessionSlotID2* slotID = NULL;

    if ( array.Count() > 0 )

        {

        // only one active slot per application at the moment

        CPEngNWSessionSlotID2* tempSlotID = array[ 0 ];

        slotID = tempSlotID->CloneL();

        }

    else

        {

        // not found

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy(); //array

    return slotID;

    }

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

// CIMPSPresenceConnectionUiImp::GetLoggedInSapL()

//

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

//

TInt CIMPSPresenceConnectionUiImp::GetLoggedInSapL( const CPEngNWSessionSlotID2& aNWSessionSlotID,

                                                    CIMPSSAPSettings& aSap )

    {

    iSapStoreProxy.PushOwnedSapStoreReleaseLC();

    TIMPSConnectionClient client;

    if ( 0 == aNWSessionSlotID.AppId().Compare( KPEngAppIdIM ) )

        {

        client = EIMPSConnClientIM;

        }

    else

        {

        client = EIMPSConnClientPEC;

        }

    TBool connected = iConnHandler->GetLoggedInSapL( aSap, client );

    CleanupStack::PopAndDestroy(); //PushOwnedSapStoreReleaseLC

    if ( connected )

        {

        return KErrNone;

        }

    else

        {

        aSap.Reset();

        return KErrNotFound;

        }

    }

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

// CIMPSPresenceConnectionUiImp::PureServiceStatusL()

//

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

//

TPEngNWSessionSlotState CIMPSPresenceConnectionUiImp::PureServiceStatusL(

    const CPEngNWSessionSlotID2& aNWSessionSlotID )

    {

    return iConnHandler->ServiceStatusL( aNWSessionSlotID );

    }

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

// CIMPSPresenceConnectionUiImp::CurrentConnectionOperationL()

//

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

//

TIMPSConnectionOperation CIMPSPresenceConnectionUiImp::CurrentConnectionOperationL(

    HBufC*& aAddtionalDesc )

    {

    aAddtionalDesc = NULL;

    TIMPSConnectionOperation currectOp = EIMPSConnOppUnknown;

    MCnUiSignaller* loginSignaller = CreateConnUiSignallerLC();

    if ( loginSignaller->OperationRunning() )

        {

        currectOp = EIMPSConnOppClientLogin;

        loginSignaller->OperationDetailsL( aAddtionalDesc );

        if ( !aAddtionalDesc )

            {

            //method semantic promises that if the operation is

            //EIMPSConnOppClientLogin, it will always have a

            //server name as aAddtionalDesc ==> create empty buf if missing server name

            aAddtionalDesc = HBufC::NewL( 0 );

            }

        }

    CleanupStack::PopAndDestroy(); //loginSignaller

    return currectOp;

    }

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

// CIMPSPresenceConnectionUiImp::MapToUiLoginReturnStatus()

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

//

TInt CIMPSPresenceConnectionUiImp::MapToUiLoginReturnStatus( TInt aOperationResult )

    {

    TInt mappedError = KErrNone;

    switch ( aOperationResult )

        {

            //falltrough

        case KErrNone: //  Login succeeded

        case KErrCancel: //User has cancelled the login at some point.

            {

            //these are returned as is

            mappedError = aOperationResult;

            break;

            }

        case KCnUiErrorNoProperDefaultSap:

            {

            //Missing the whole default SAP / or no SAP's at all

            mappedError = KErrNotFound;

            break;

            }

        case KCnUiErrorSapMissingCompulsoryFields:

            {

            //Default or selected SAP to login was missing some required fields.

            mappedError = KErrArgument;

            break;

            }

        case KCnUiErrorClientAlreadyConnected:

            {

            //Current client is already logged in. (Thus not a real error.)

            mappedError = KErrAlreadyExists;

            break;

            }

        default:

            {

            //General failure during login (no connection to network, network access denied, etc..)

            mappedError = KErrGeneral;

            break;

            }

        }

    return mappedError;

    }

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

// CIMPSPresenceConnectionUiImp::StoreNWSessionOwnership()

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

//

void CIMPSPresenceConnectionUiImp::StoreNWSessionOwnershipL(

    const CPEngNWSessionSlotID2& aNWSessionSlotID )

    {

    IMPSCUI_DP( D_IMPSCUI_LIT( "CIMPSPresenceConnectionUiImp::StoreNWSessionOwnership()" ) );

    CPEngNWSessionSlot2* sessionSlot = CPEngNWSessionSlot2::NewLC( aNWSessionSlotID );

    // get the ownership of this slot

    User::LeaveIfError( sessionSlot->OpenNWPresenceSessionOwnership() );

    // store the ownership so that PECEngine does not close the session when

    // session slot objects are deleted

    TInt err = sessionSlot->StoreNWPresenceSessionOwnership( aNWSessionSlotID.AppId() );

    // Ignore KErrAlreadyExists

    if ( err != KErrAlreadyExists && err != KErrNone )

        {

        User::Leave( err );

        }

    CleanupStack::PopAndDestroy( sessionSlot ); // sessionSlot, slotID

    }

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

// CIMPSPresenceConnectionUiImp::ReStoreNWSessionOwnership()

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

//

void CIMPSPresenceConnectionUiImp::ReStoreNWSessionOwnershipL()

    {

    IMPSCUI_DP( D_IMPSCUI_LIT( "CIMPSPresenceConnectionUiImp::ReStoreNWSessionOwnership()" ) );

    CPEngNWSessionSlotID2* slotID = NULL;

    // get the active network session slot

    TRAPD( err, slotID = GetActiveNWSessionSlotIDL( iClient ) );

    if ( err == KErrNotFound )

        {

        // no active network session slot for this client

        // we can just return

        return;

        }

    else if ( err != KErrNone )

        {

        User::Leave( err );

        }

    // we got the active slot's ID

    CleanupStack::PushL( slotID );

    CPEngNWSessionSlot2* sessionSlot = CPEngNWSessionSlot2::NewLC( *slotID );

    TPtrC ownership;

    if ( iClient == EIMPSConnClientPEC )

        {

        ownership.Set( KPEngAppIdPEC() );

        }

    else

        {

        ownership.Set( KPEngAppIdIM() );

        }

    // restore the ownership so that PECEngine will close the session when

    // session slot objects are deleted

    err = sessionSlot->RestoreNWPresenceSessionOwnership( ownership );

    if ( err == KErrNotFound )

        {

        // there was no stored session ownership

        // so we really don't need to do anything

        CleanupStack::PopAndDestroy( 2, slotID ); // sessionSlot, slotID

        return;

        }

    else if ( err != KErrNone )

        {

        User::Leave( err );

        }

    // give this slot to connection handler

    iConnHandler->SetSessionSlotL( sessionSlot );

    CleanupStack::Pop( sessionSlot );

    CleanupStack::PopAndDestroy( slotID ); // sessionSlot

    }

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

// CIMPSPresenceConnectionUiImp::LoggedInL()

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

//

TBool CIMPSPresenceConnectionUiImp::LoggedInL( TIMPSConnectionClient aClient )

    {

    CPEngNWSessionSlotID2* slotID = NULL;

    TRAPD( err, slotID = GetActiveNWSessionSlotIDL( aClient ) );

    if ( err == KErrNotFound )

        {

        // no session slots -> not logged in

        return EFalse;

        }

    else

        {

        // for other errors we have to leave

        User::LeaveIfError( err );

        }

    // slot found, we are logged in

    delete slotID;

    return ETrue;

    }

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

// CIMPSPresenceConnectionUiImp::DisplayDomainSelectionQueryL

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

//

TInt CIMPSPresenceConnectionUiImp::DisplayDomainSelectionQueryL(

    TDes& aSelectedDomain,

    CIMPSSAPSettings* aSap )

    {

    return CCnUiUiControlContext::DisplayDomainSelectionQueryL(

               aSelectedDomain, aSap );

    }

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

// CIMPSPresenceConnectionUiImp::DestroyCloseModelArray()

//

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

//

void CIMPSPresenceConnectionUiImp::DestroyCloseModelArray( TAny* aObject )

    {

    reinterpret_cast< RPointerArray< CPEngNWSessionSlotID2 >* >( aObject )->ResetAndDestroy();

    }

//  End of File