/*

* 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: Class for handling the login issues.

*

*/

// INCLUDE FILES

#include <Cwvsapsettingsstore.h>

#include <Cwvsapsettings.h>

#include <imerrors.h>

#include "loginmngr.h"

#include "apiutils.h"

#include "imconnectionimpl.h"

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

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

// CLoginManager::CLoginManager

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

// might leave.

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

//

CLoginManager::CLoginManager( RImpsEng& aEngine, CImConnectionImpl& aConnection )

        :   CActive( EPriorityStandard ),

        iState( EReady ),

        iLoggedIn( EFalse ),

        iEngine( aEngine ),

        iEngineState( EImps_NOT_LOGGED ),

        iObserver( NULL ),

        iConnection( aConnection )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CLoginManager: Construction" ) );

#endif

    CActiveScheduler::Add( this );

    }

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

// CLoginManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLoginManager::ConstructL()

    {

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

    // Register to the IMPS Access Client

    iAccessClient.RegisterL( iEngine, this );

    iAccessClient.RegisterErrorObserverL( *this );

    }

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

// CLoginManager::NewL

// Two-phased constructor.

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

//

CLoginManager* CLoginManager::NewL( RImpsEng& aEngine,

                                    CImConnectionImpl& aConnection )

    {

    CLoginManager* self = new( ELeave ) CLoginManager( aEngine, aConnection );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CLoginManager::~CLoginManager()

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CLoginManager: Destruction" ) );

#endif

    Cancel();

    iAccessClient.Unregister();

    TRAPD( err, iAccessClient.UnregisterErrorObserverL() );

    }

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

// CLoginManager::HandleLoginL

//

//

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

//

void CLoginManager::HandleLoginL(

    TInt /*aId*/,

    TImpsCspIdentifier& /*aCspId*/ )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CLoginManager: HandleLogin" ) );

#endif

    iLoggedIn = ETrue;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    }

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

// CLoginManager::HandleLoginCancelL

//

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

//

void CLoginManager::HandleLoginCancelL(

    TInt aCancelledOpId,

    TImpsCspIdentifier& /*aCspId*/ )

    {

    }

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

// CLoginManager::HandleLoginStatusL

//

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

//

//void CLoginManager::HandleLoginStatusL(

//                                      TInt /*aId*/,

//                                      TInt aStatus,

//                                      TBool aIsLoggedIn )

//    {

//#ifdef _DEBUG

//    CImApiLogger::Log(_L("CLoginManager: HandleLoginStatus: %d"), aStatus);

//    CImApiLogger::Log(_L("CLoginManager: Is logged in: %d"), aIsLoggedIn);

//#endif

//    iLoggedIn = aIsLoggedIn;

//    TRequestStatus* status = &iStatus;

//    User::RequestComplete(status, aStatus);

//    }

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

// CLoginManager::HandleLogoutL

//

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

//

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

                                   TImpsCspIdentifier& aCspId )

    {

#ifdef _DEBUG

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

#endif

    iLoggedIn = EFalse;

    }

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

// CLoginManager::HandleErrorL

//

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

//

void CLoginManager::HandleErrorL( TInt aStatus,

                                  TInt /*aOpId*/,

                                  const TDesC* /*aDescription*/,

                                  const CImpsDetailed* /*aDetailedRes*/,

                                  TImpsCspIdentifier& aCspId )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CLoginManager: Error received: %d" ), aStatus );

#endif

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, aStatus );

    }

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

// CLoginManager::HandleStatusChangeL

//

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

//

void CLoginManager::HandleStatusChangeL( TImpsServiceStatus aStatus )

    {

#ifdef _DEBUG

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

#endif

    iEngineState = aStatus;

    switch ( aStatus )

        {

        case EImps_NOT_LOGGED:

            iLoggedIn = EFalse;

            break;

        case EImps_ON_LINE:

            iLoggedIn = ETrue;

            break;

        case EImps_OFF_LINE:

        case EImps_NO_IAP:

        default:

            break;

        }

    }

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

// CLoginManager::HandleNbrSessionsL

//

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

//

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

                                        TInt /*aNbr*/,

                                        TImpsCspIdentifier& /*aCspId*/ )

    {

    }

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

// CLoginManager::StartRegistration

//

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

//

TInt CLoginManager::StartLogin( MLoginObserver* aObserver )

    {

//#ifdef _DEBUG

//    CImApiLogger::Log(_L("CLoginManager: Login started"));

//#endif

//

//    if ( IsActive() )

//        {

//        return KImApiErrConnectingInProgress;

//        }

//    iObserver = aObserver;

//    iState = EInitializing;

//    iStatus = KRequestPending;

//    SetActive();

//    TRequestStatus* status = &iStatus;

//    User::RequestComplete(status, KErrNone);

    return KErrNone;

    }

//

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

// CLoginManager::IsLoggedIn()

//

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

//

TBool CLoginManager::IsLoggedIn() const

    {

    return iLoggedIn;

    }

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

// CLoginManager::EngineStatus()

//

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

//

TImpsServiceStatus CLoginManager::EngineStatus() const

    {

    return iEngineState;

    }

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

// CLoginManager::CancelLogin()

//

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

//

void CLoginManager::CancelLogin( )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CLoginManager: Login canceled" ) );

#endif

    Cancel();

    }

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

// CLoginManager::RunL

//

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

//

void CLoginManager::RunL()

    {

    User::LeaveIfError( iStatus.Int() );

    switch ( iState )

        {

        case EInitializing:

            {

#ifdef _DEBUG

            CImApiLogger::Log( _L( "CLoginManager: Calling IsLoggedIn()" ) );

#endif

//            iAccessClient.IsLoggedInL();

            iState = ELoggingIn;

            iStatus = KRequestPending;

            SetActive();

            }

        break;

        case ELoggingIn:

            if ( !iLoggedIn )

                { // Do Login

                // Get the default login params from SAP settings

                CWVSAPSettingsStore* store = CWVSAPSettingsStore::NewLC(); // <<<

                CWVSAPSettings* sapSettings = CWVSAPSettings::NewLC();     // <<<

                store->GetDefaultL( *sapSettings );

                const TDesC& server = sapSettings->SAPAddress();

                const TDesC& user = sapSettings->SAPUserId();

                const TDesC& passwd = sapSettings->SAPUserPassword();

                const TDesC& clientId = sapSettings->ClientId();

                TUint32 myAP = sapSettings->AccessPoint();

//                const TDesC& proxy = sapSettings->HTTPProxyAddress();

                const TDesC& key1 = sapSettings->SAPSpecificString1();

                const TDesC& key2 = sapSettings->SAPSpecificString2();

#ifdef _DEBUG

                CImApiLogger::Log( _L( "CLoginManager: Logging in:" ) );

                CImApiLogger::Log( _L( "    Server: %S" ), &server );

                CImApiLogger::Log( _L( "    User: %S" ), &user );

                CImApiLogger::Log( _L( "    Password: %S" ), &passwd );

//                CImApiLogger::Log(_L("    ClientID: %S"),iClientID);

                CImApiLogger::Log( _L( "    IAP: %d" ), myAP );

//                CImApiLogger::Log(_L("    Proxy: %S"),&proxy);

#endif

#ifdef _DEBUG

                CImApiLogger::Log( _L( "CLoginManager: Logging in" ) );

#endif

//                iAccessClient.LoginL(

//                    server,

//                    user,

//                    passwd,

//                    // because of AOL we need the client ID from SAP settings

//                    // iConnection.ClientId(),

//                    clientId,

//                    myAP,

//                    //proxy, Not used!

//                    KNullDesC,

//                    &key1,

//                    &key2);

                iState = EFinishing;

                iStatus = KRequestPending;

                SetActive();

                CleanupStack::PopAndDestroy( 2 );   // >>> sapSettings, store

                }

            else

                {

                // already logged in -> just finish

#ifdef _DEBUG

                CImApiLogger::Log( _L( "CLoginManager: Already logged in." ) );

#endif

                iState = EFinishing;

                iStatus = KRequestPending;

                SetActive();

                TRequestStatus* s = &iStatus;

                User::RequestComplete( s, KErrNone );

                }

            break;

        case EFinishing:

            NotifyObserver( KErrNone );

            iState = EReady;

            break;

        case EReady:

        default:

            break;

        }

    }

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

// CLoginManager::RunError

//

// Returns: <KErrNone>:

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

//

TInt CLoginManager::RunError( TInt aError )

    {

#ifdef _DEBUG

    CImApiLogger::Log( _L( "CLoginManager: RunL leaves: %d" ), aError );

#endif

    NotifyObserver( aError );

    return KErrNone;

    }

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

// CLoginManager::DoCancel

//

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

//

void CLoginManager::DoCancel()

    {

    iState = EInitializing;

    }

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

// CLoginManager::NotifyObservers

//

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

//

void CLoginManager::NotifyObserver( TInt aError )

    {

    iObserver->HandleLogin( aError );

    }

//  End of File