/*

* 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: Implementation of the CImConnection interface (imconnection.h)

*

*/

// INCLUDE FILES

#include    "imconnectionimpl.h"

#include    "imerrors.h"

#include    "imclientimpl.h"

#include    "cntdbreader.h"

#include    "apiutils.h"

#include    <impserrors.h>

//#include    <centralrepository.h>

#include    <wvengineInternalCRKeys.h>

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

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

// CImConnectionImpl::CImConnectionImpl

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

// might leave.

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

//

CImConnectionImpl::CImConnectionImpl():

        iCurrentOpId( 0 ),

        iState( EImNotLogged )

    {

    }

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

// CImConnectionImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CImConnectionImpl::ConstructL( TDesC& aApplicationId )

    {

    User::LeaveIfError( iEngine.Connect() );

    iApplicationId = aApplicationId.AllocL();

    iContactReader = CContactDBReader::NewL();

    /*// Read the CSP version from CenRep

    TReal                   cspVersion; // the CSP version

    CRepository* repository = CRepository::NewLC(KCRUIDWVEngineVariation);

    repository->Get(KWVEngineCspVersion, cspVersion);

    CleanupStack::PopAndDestroy(); // repository

    if ( cspVersion < 1.2 )

        {

        // the CSP version is too low

        User::Leave(KErrNotSupported);

        }*/

    }

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

// CImConnectionImpl::NewL

// Two-phased constructor.

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

//

CImConnectionImpl* CImConnectionImpl::NewL( TDesC& aApplicationId )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CImConnectionImpl: NewL %S" ), &aApplicationId );

#endif

    CImConnectionImpl* self = new( ELeave ) CImConnectionImpl();

    CleanupStack::PushL( self );

    self->ConstructL( aApplicationId );

    CleanupStack::Pop( );

    return self;

    }

// Destructor

CImConnectionImpl::~CImConnectionImpl()

    {

    delete iApplicationId;

    delete iContactReader;

    iEngine.Close();

    }

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

// CImConnectionImpl::CreateImClientL

// Factory function to create CImClient object

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

//

MImClient* CImConnectionImpl::CreateImClientL()

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CImConnectionImpl: CreateImClientL" ) );

#endif

    return CImClient::NewL( *this );

    }

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

// CImConnectionImpl::RegisterObserverL

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

//

void CImConnectionImpl::RegisterObserverL( MImConnectionObserver* aObserver )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CImConnectionImpl: RegisterObserverL" ) );

#endif

    if ( iClientObserver )

        {

        User::Leave( KImApiErrAlreadyRegistered );

        }

    iAccessClient.RegisterL(

        iEngine,

        this );

    iAccessClient.RegisterErrorObserverL( *this );

    iAccessClient.RegisterStatusObserverL( this );

    iClientObserver = aObserver;

    }

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

// CImConnectionImpl::UnregisterObserverL

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

//

void CImConnectionImpl::UnregisterObserver()

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CImConnectionImpl: UnregisterObserver" ) );

#endif

    if ( iClientObserver != NULL )

        {

        iClientObserver = NULL;

        iAccessClient.Unregister();

        TInt err;

        TRAP( err, iAccessClient.UnregisterErrorObserverL() );

        TRAP( err, iAccessClient.UnregisterStatusObserverL() );

        }

    }

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

// CImConnectionImpl::LoginL

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

//

void CImConnectionImpl::LoginL(

    const TDesC& aServer,

    const TDesC& aUserID,

    const TDesC& aPassword,

    const TUint32 aAP )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CImConnectionImpl: LoginL" ) );

#endif

    switch ( iState )

        {

        case EImLoggingIn:

            User::Leave( KImApiErrLoginInProgress );

        case EImLoggingOut:

            User::Leave( KImApiErrLogoutInProgress );

        case EImCancelingLogin:

            User::Leave( KImApiErrCancelLoginInProgress );

        case EImLoggedIn:

            User::Leave( KImApiErrAlreadyLoggedIn );

        default: ; // EImNotLogged -> just continue

        }

    // check whether registered

    if ( !iClientObserver )

        {

        User::Leave( KImApiErrNotRegistered );

        }

    // We need to get the ClientID in from SAP Settings

    // some servers will not allow logging in without that

    const TDesC* clientId = NULL;

    clientId = SSapSettingsReader::ClientIdLC( aServer );

    iCurrentOpId = iAccessClient.LoginL(

                       TImpsCspIdentifier( aServer, aUserID ),

                       aPassword,

                       clientId ? *clientId : KNullDesC,

                       aAP,

                       NULL,

                       NULL

                   );

    if ( clientId != NULL )

        CleanupStack::PopAndDestroy( 1 ); // clientId

    SetState( EImLoggingIn );

    }

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

// CImConnectionImpl::CancelLoginL

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

//

void CImConnectionImpl::CancelLoginL()

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CImConnectionImpl: CancelLoginL" ) );

#endif

    switch ( iState )

        {

        case EImLoggedIn:

            User::Leave( KImApiErrAlreadyLoggedIn );

        case EImCancelingLogin:

            User::Leave( KImApiErrCancelLoginInProgress );

        case EImLoggingOut:

            User::Leave( KImApiErrLogoutInProgress );

        case EImNotLogged:

            User::Leave( KImApiErrNotLogged );

        default:; // EImLoggingIn -> just continue

        }

    iAccessClient.CancelLoginL( iCurrentOpId );

    SetState( EImCancelingLogin );

    }

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

// CImConnectionImpl::LoginL

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

//

void CImConnectionImpl::LogoutL()

    {

    switch ( iState )

        {

        case EImLoggingIn:

            User::Leave( KImApiErrNotLogged );

        case EImCancelingLogin:

            User::Leave( KImApiErrCancelLoginInProgress );

        case EImLoggingOut:

            User::Leave( KImApiErrLogoutInProgress );

        case EImNotLogged:

            User::Leave( KImApiErrNotLogged );

        default:; // EImLoggedIn -> just continue

        }

    iAccessClient.LogoutL();

    SetState( EImLoggingOut );

    }

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

// CImConnectionImpl::ImConnectionStatus

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

//

TImConnectionStatus CImConnectionImpl::ImConnectionStatus()

    {

    return ( iState == EImLoggedIn ) ? ELoggedIn : ENotLoggedIn;

    }

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

// CLoginManager::HandleLoginL

//

//

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

//

void CImConnectionImpl::HandleLoginL(

    TInt /*aId*/,

    TImpsCspIdentifier& /*aCspId*/ )

    {

    // Called when login has finished

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CImConnectionImpl: HandleLoginL" ) );

#endif

    SetState( EImLoggedIn );

    if ( iClientObserver )

        {

        iClientObserver->HandleLoginL( KErrNone );

        }

    }

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

// CLoginManager::HandleLoginCancelL

//

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

//

void CImConnectionImpl::HandleLoginCancelL(

    TInt /*aCancelledOpId*/,

    TImpsCspIdentifier& /*aCspId*/ )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CImConnectionImpl: HandleLoginCancelL" ) );

#endif

    SetState( EImNotLogged );

    if ( iClientObserver )

        {

        iClientObserver->HandleCancelLoginL( KErrNone );

        }

    }

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

// CLoginManager::HandleLogoutL

//

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

//

void CImConnectionImpl::HandleLogoutL( TInt /*aId*/,

                                       TImpsCspIdentifier& /*aCspId*/ )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CImConnectionImpl: HandleLogoutL" ) );

#endif

    SetState( EImNotLogged );

    if ( iClientObserver )

        {

        iClientObserver->HandleLogoutL( KErrNone );

        }

    }

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

// CLoginManager::HandleErrorL

//

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

//

void CImConnectionImpl::HandleErrorL( TInt aStatus,

                                      TInt /*aOpId*/,

                                      const TDesC* /*aDescription*/,

                                      const CImpsDetailed* /*aDetailedRes*/,

                                      TImpsCspIdentifier& /*aCspId*/ )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CImConnectionImpl: Error received: %d in state: %d" ), aStatus, iState );

#endif

    if ( iClientObserver )

        {

        TInt apiErrorCode = ConvertImpsEngineErrorCode( aStatus );

        // distribute the error to the correct handler

        switch ( iState )

            {

            case EImLoggingIn:

                SetState( EImNotLogged );

                iClientObserver->HandleLoginL( apiErrorCode );

                break;

            case EImCancelingLogin:

                iClientObserver->HandleCancelLoginL( apiErrorCode );

                // here the state change is tricky, it is better to wait the

                // status change

                break;

            case EImLoggingOut:

                SetState( EImNotLogged );

                iClientObserver->HandleLogoutL( apiErrorCode );

                break;

            default:

                ;

            }

        }

    }

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

// CLoginManager::HandleStatusChangeL

//

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

//

void CImConnectionImpl::HandleStatusChangeL(

    TImpsServiceStatus aStatus,

    TImpsCspIdentifier& /*aCspId*/ )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CLoginManager: Status changed: %d" ), aStatus );

#endif

    // change our status according to the engine

    // this is a good opportunity to synch or state to engine's

    switch ( aStatus )

        {

        case EImps_NOT_LOGGED:

            SetState( EImNotLogged );

            break;

        case EImps_ON_LINE:

            SetState( EImLoggedIn );

            break;

        default:

            break;

        }

    }

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

// CLoginManager::HandleNbrSessionsL

//

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

//

void CImConnectionImpl::HandleNbrSessionsL( TInt /*aId*/,

                                            TInt /*aNbr*/,

                                            TImpsCspIdentifier& /*aCspId*/ )

    {

    }

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

// CImConnectionImpl::CreateImStatusFetcherL

// Factory function CIMStatusFetcherImpl object

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

//

RImpsEng& CImConnectionImpl::ImpsEngine()

    {

    return iEngine;

    }

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

// CImConnectionImpl::ContactDBReader

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

//

CContactDBReader& CImConnectionImpl::ContactDBReader()

    {

    return *iContactReader;

    }

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

// CImConnectionImpl::ClientId

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

//

const TDesC& CImConnectionImpl::ApplicationId()

    {

    return *iApplicationId;

    }

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

// CImConnectionImpl::ConvertImpsEngineErrorCode

// Converts the IMPS engine error code to an API error code

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

//

TInt CImConnectionImpl::ConvertImpsEngineErrorCode( TInt aErrorCode )

    {

    // Do not try to convert KErrNone

    if ( aErrorCode == KErrNone )

        {

        return KErrNone;

        }

    TInt returnValue;

    switch ( aErrorCode )

        {

        case KImpsErrorNotLogged:

            returnValue = KImApiErrNotLogged;

            break;

        case Imps_ERROR_BASE-409: // Wrong password

            returnValue = KImApiErrWrongPassword;

            break;

        case Imps_ERROR_BASE-531: // User does not exist

            returnValue = KImApiErrInvalidUserId;

            break;

        case Imps_ERROR_BASE-201: // Partial success

            returnValue = KImApiErrPartialSuccess;

            break;

        default: // KImpsErrorOthersLogged

            // KImpsErrorShuttingDown,

            // KImpsErrorBearerSuspended

            returnValue = KImApiGeneralError;

        }

    return returnValue;

    }

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

// CImConnectionImpl::SetState

// Changes the internal state of the object

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

//

void CImConnectionImpl::SetState( TConnectionState aNewState )

    {

    iState = aNewState;

    }

//  End of File