/*

* Copyright (c) 2005 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 manager

*

*/

// INCLUDE FILES

#include <in_sock.h>

#include <es_enum.h>

#include <f32file.h>

#include <flogger.h>

#include "msgconntimer.h"

#include "msgconnmanager.h"

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

//

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

// CMsgConnManager::CMsgConnManager

// 

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

//

CMsgConnManager::CMsgConnManager() : CActive( EPriorityUserInput + 2 ),

                                     iProgressStarted( EFalse ),

                                     iConnectionClosed( ETrue )

    {

    }

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

// CMsgConnManager::NewL

// 

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

//

CMsgConnManager* CMsgConnManager::NewL( const TInt aAccessPoint )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aAccessPoint );

    CleanupStack::Pop();

    return self;

    }

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

// CMsgConnManager::ConstructL

// 

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

//

void CMsgConnManager::ConstructL( const TInt aAccessPoint )

    {

    DeleteLogFileL();

    iAccessPointID = aAccessPoint;

    iConnectionTimer = CMsgConnTimer::NewL();

    iCommsDatabase = CCommsDatabase::NewL( EDatabaseTypeUnspecified );

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

    User::LeaveIfError( iConnection.Open( iSocketSession ) );

    iConnectionClosed = EFalse;

    iAccessPointSettings.SetIapId( aAccessPoint );

    iAccessPointSettings.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

    #ifdef _DEBUG

        WriteToLog( _L8( "CONNMAN: LOGGING ENABLED" ) );

    #endif

    CActiveScheduler::Add( this );

    }

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

// CMsgConnManager::~CMsgConnManager

// 

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

//

CMsgConnManager::~CMsgConnManager()

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "CMsgConnManager::~CMsgConnManager(), Destructor." ) );

    #endif

    Cancel();

    delete iCommsDatabase;

    delete iConnectionTimer;

    iConnection.Close();

    iSocketSession.Close();

    iEventSubscribers.Close();

    }

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

// CMsgConnManager::DeleteLogFileL

// 

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

//

void CMsgConnManager::DeleteLogFileL()

    {

    RFs session;

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

    CFileMan* manager = CFileMan::NewL( session );

    manager->Delete( _L("C:\\logs\\MsgConnMan\\*.*") );

    session.Close();

    delete manager;

    manager = NULL;

    }

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

// CMsgConnManager::StartBearerObserver

// 

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

//

void CMsgConnManager::StartNetworkObserver()

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "CMsgConnManager::StartNetworkObserver()  Closed: %d" ), iConnectionClosed );

    #endif

    #ifdef __WINS__

        if( !iConnectionClosed )

            {

            iStatus = KRequestPending;

            SetActive();

            }

    #else

        if( !iConnectionClosed )

            {

            if( !IsActive() )

                {

                iStatus = KRequestPending;

                iConnection.ProgressNotification( iProgressBuffer, iStatus );

                SetActive();

                }

            }

    #endif

    }

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

// CMsgConnManager::RunL()

// 

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

//

void CMsgConnManager::RunL()

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "CMsgConnManager::RunL(), iConnManStatus: %d  iStatus: %d  iStage: %d  iError: %d" ),

                    iConnManStatus, iStatus.Int(), iProgressBuffer().iStage, iProgressBuffer().iError );

    #endif

    switch( iConnManStatus ) 

        {

        case EMsgConnManWaitingForStartComplete:

            #ifdef _DEBUG

                WriteToLog( _L8( " Current status is EMsgConnManWaitingForStartComplete." ) );

            #endif

            WatchConnectionOpening();

            break;

        case EMsgConnManWaitingForNotifications:

            #ifdef _DEBUG

                WriteToLog( _L8( " Current status is EMsgConnManWaitingForNotifications." ) );

            #endif

            WatchConnectionOpening();

            break;

        case EMsgConnManObservingAccessPoint:

            #ifdef _DEBUG

                WriteToLog( _L8( " Current status is EMsgConnManObservingAccessPoint." ) );

            #endif

            DetermineConnectionStatusL();

            break;

        case EMsgConnManBearerSuspended:

            #ifdef _DEBUG

                WriteToLog( _L8( " Current status is EMsgConnManBearerSuspended." ) );

            #endif

            DetermineConnectionStatusL();

            break;

        case EMsgConnManDisconnectingPrevious:

            #ifdef _DEBUG

                WriteToLog( _L8( " Timer expired, complete client's request." ) );

            #endif

            User::RequestComplete( iTimedCompleteStatus, KErrNone );

            iConnManStatus = EMsgConnManIdle;

            break;

        case EMsgConnManIdle:

            #ifdef _DEBUG

                WriteToLog( _L8( " Idle, iStatus is %d." ), iStatus.Int() );

            #endif

            break;

        default:

            #ifdef _DEBUG

                WriteToLog( _L8( " Default case, should not be here." ) );

            #endif

            break;

        }

    #ifdef _DEBUG

        WriteToLog( _L8( " RunL() ends" ) );

    #endif

    }

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

// CMsgConnManager::WatchConnectionOpening()

// 

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

//

void CMsgConnManager::WatchConnectionOpening()

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "  CMsgConnManager::WatchConnectionOpening() - iProgressStarted: %d" ), iProgressStarted );

    #endif

    //Lets quit right away if it is an error

    if( iStatus != KErrNone )

        {

        #ifdef _DEBUG

            WriteToLog( _L8( "   Something wrong, complete with error: %d." ), iStatus.Int() );

        #endif

        iConnectionTimer->Cancel();

        if( iConnManStatus == EMsgConnManWaitingForNotifications )

            iConnection.CancelProgressNotification();

        iConnection.Close();

        iConnectionClosed = ETrue;

        User::RequestComplete( iClientStatus, iStatus.Int() );

        iConnManStatus = EMsgConnManIdle;

        }

    else

        {

        if( iProgressStarted )

            {

            iLastConnectionStage = iProgressBuffer().iStage;

            if( iLastConnectionStage == KLinkLayerOpen )  //we are done

                {

                #ifdef _DEBUG

                    WriteToLog( _L8( "   Connected. Completing with KErrNone." ) );

                #endif

                iConnectionTimer->Cancel();

                iConnManStatus = EMsgConnManObservingAccessPoint;

                StartNetworkObserver();

                User::RequestComplete( iClientStatus, KErrNone );

                iProgressStarted = EFalse;

                }

            else

                {

                #ifdef _DEBUG

                    WriteToLog( _L8( "   Keep on waiting for progress." ) );

                #endif

                IssueRequest();

                }

            }

        else

            {

            #ifdef _DEBUG

                WriteToLog( _L8( "   Start complete, watch progress." ) );

            #endif

            if( iConnManStatus == EMsgConnManWaitingForStartComplete )

                {

                iProgressStarted = ETrue;

                iConnManStatus = EMsgConnManWaitingForNotifications;

                }

            IssueRequest();

            }

        }

    }

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

// CMsgConnManager::DetermineConnectionStatus()

// 

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

//

void CMsgConnManager::DetermineConnectionStatusL()

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "  CMsgConnManager::DetermineConnectionStatus()" ) );

    #endif

    #ifdef __WINS__

        Cancel();

        switch( iStatus.Int() )

    #else

        switch( iProgressBuffer().iStage )

    #endif

        {

        case KLinkLayerClosed:

        case KConnectionUninitialised:

            #ifdef _DEBUG

                CMsgConnManager::WriteToLog( _L8( "   KLinkLayerClosed, notify clients of EMsgBearerLost" ) );

            #endif

            Cancel();

            iConnManStatus = EMsgConnManBearerLost;

            BroadcastBearerEventL( EMsgBearerLost );

            iConnection.Close();

            iConnectionClosed = ETrue;

            iEventSubscribers.Reset();

            iConnManStatus = EMsgConnManIdle;

            break;

        case KLinkLayerOpen:

            #ifdef _DEBUG

                WriteToLog( _L8( "   KLinkLayerOpen -> GPRS Context Active." ) );

            #endif

            if( iConnManStatus == EMsgConnManBearerSuspended )

                {

                #ifdef _DEBUG

                    WriteToLog( _L8( "   Moving to active state." ) );

                #endif

                iConnManStatus = EMsgConnManObservingAccessPoint;

                BroadcastBearerEventL( EMsgBearerActive );

                StartNetworkObserver();

                }

            break;

        case KDataTransferTemporarilyBlocked:

            #ifdef _DEBUG

                WriteToLog( _L8( "   KDataTransferTemporarilyBlocked -> GPRS Context Suspended." ) );

            #endif

            if( iConnManStatus != EMsgConnManBearerSuspended )

                {

                #ifdef _DEBUG

                    WriteToLog( _L8( "   Moving to suspended state." ) );

                #endif

                iConnManStatus = EMsgConnManBearerSuspended;

                BroadcastBearerEventL( EMsgBearerSuspended );

                }

            StartNetworkObserver();

            break;

        default:

            #ifdef _DEBUG

                #ifdef __WINS__

                    if( iStatus.Int() == KErrCancel )

                        WriteToLog( _L8( "   Bearer event generation cancelled" ) );

                    else

                        WriteToLog( _L8( "   Some weird status: %d" ), iStatus.Int() );

                #else

                    WriteToLog( _L8( "   Default case! WTF?!?" ) );

                #endif

            #endif

            StartNetworkObserver();

            break;

        }     

    }

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

// CMsgConnManager::CancelStartL

// 

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

//

void CMsgConnManager::CancelStartL()

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "CMsgConnManager::CancelStartL()" ) );

    #endif

    if( iClientStatus != NULL && iClientStatus->Int() == KRequestPending )

        {

        if( iConnManStatus == EMsgConnManWaitingForStartComplete ||

            iConnManStatus == EMsgConnManWaitingForNotifications )

            {

            Cancel();

            iEventSubscribers.Reset();

            User::RequestComplete( iClientStatus, KErrCancel );

            iConnManStatus = EMsgConnManIdle;

            iConnectionClosed = ETrue;

            }

        else User::Leave( KErrAbort );

        }

    else User::Leave( KErrAbort );

    }

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

// CMsgConnManager::StopConnection

// 

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

//

void CMsgConnManager::StopConnection()

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "CMsgConnManager::StopConnection()" ) );

    #endif

    if( iConnManStatus == EMsgConnManWaitingForStartComplete ||

        iConnManStatus == EMsgConnManWaitingForNotifications ||

        iConnManStatus == EMsgConnManIdle )

        {

        #ifdef _DEBUG

            WriteToLog( _L8( "  Status is %d, wrong state for this operation. Abort." ), iConnManStatus );

        #endif

        }

    else

        {

        //If bearer has been lost, we're already closed

        if( iConnManStatus != EMsgConnManBearerLost )

            {

            Cancel();

            iConnection.Close();

            iConnectionClosed = ETrue;

            iEventSubscribers.Reset();

            iConnManStatus = EMsgConnManIdle;

            }

        }

    #ifdef _DEBUG

        WriteToLog( _L8( "  StopConnection() ends." ) );

    #endif

    }

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

// CMsgConnManager::StopConnection

// 

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

//

void CMsgConnManager::StopConnection( TRequestStatus& aStatus )

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "CImpsConnectionManager::StopConnectionL()" ) );

    #endif  

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    iTimedCompleteStatus = &aStatus;

    if( iConnManStatus == EMsgConnManWaitingForStartComplete ||

        iConnManStatus == EMsgConnManWaitingForNotifications ||

        iConnManStatus == EMsgConnManDisconnectingPrevious ||

        iConnManStatus == EMsgConnManIdle )

        {

        #ifdef _DEBUG

            WriteToLog( _L8( "  Status is %d, wrong state for this operation. Abort." ),

                                iConnManStatus );

        #endif

        User::RequestComplete( iClientStatus, KErrAbort );

        }

    else

        {

        //If bearer has been lost, we're already closed

        if( iConnManStatus != EMsgConnManBearerLost )

            {

            Cancel();

            iConnection.Close();

            iConnectionClosed = ETrue;

            iEventSubscribers.Reset();

            iConnectionTimer->ActivateTimer( iStatus, 4000000 );

            iConnManStatus = EMsgConnManDisconnectingPrevious;

            SetActive();

            }

        else

            {

            #ifdef _DEBUG

                WriteToLog( _L8( "  Bearer lost, nothing to do. Complete with KErrNone" ) );

            #endif

            User::RequestComplete( iClientStatus, KErrNone );

            }

        }

    #ifdef _DEBUG

        WriteToLog( _L8( " StopConnectionL() ends" ) );

    #endif

    }

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

// CMsgConnManager::BroadcastBearerEvent

// 

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

//

void CMsgConnManager::BroadcastBearerEventL( const TMsgBearerEvent aBearerEvent )

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "CMsgConnManager::BroadcastBearerEvent" ) );

    #endif

    TInt subs = iEventSubscribers.Count();

    #ifdef _DEBUG

        WriteToLog( _L8( " %d clients subscribed." ), subs );

    #endif

    if( subs > 0 )

        {

        TBool empty = EFalse;

        MMsgBearerObsCallback* client = NULL;

        for( TInt i = 0;i < subs && !empty;i++ )

            {

            //Just in case:

            //If a client has managed to remove a listener from the queue

            //in the previous callback, "i" will index a bad handle.

            subs = iEventSubscribers.Count();

            if( subs > 0 && i < subs )

                {

                client = iEventSubscribers[i];

                __ASSERT_ALWAYS( client != NULL, User::Panic( _L( "ObserverNULL!" ), 1 ) );

                TInt error = iProgressBuffer().iError;

                if( aBearerEvent == EMsgBearerLost )

                    {

                    #ifdef _DEBUG

                        TInt stage = iProgressBuffer().iStage;

                        WriteToLog( _L8( " Event is EMsgBearerLost" ) );

                        WriteToLog( _L8( "   Stage: %d" ), stage );

                        WriteToLog( _L8( "   Error: %d" ), error );

                    #endif

                    }

                TBool authClose = error == KErrConnectionTerminated;

                client->HandleBearerEventL( authClose, aBearerEvent );

                #ifdef _DEBUG

                    WriteToLog( _L8("  Client no. %d serviced" ), i );

                #endif

                }

            else

                {

                #ifdef _DEBUG

                    WriteToLog( _L8(

                    "  An event listener was removed inside the callback!" ) );

                #endif

                //Leave the for loop

                empty = ETrue;

                }

            }

        }

    #ifdef _DEBUG

        WriteToLog( _L8( " BroadcastBearerEvent() ends" ) );

    #endif

    }

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

// CMsgConnManager::IssueRequest

// 

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

//

void CMsgConnManager::IssueRequest()

    {

    #ifdef _DEBUG

        WriteToLog( _L8( "CMsgConnManager::IssueRequest(), status: %d" ), IsActive() );

    #endif

    iStatus = KRequestPending;

    iConnection.ProgressNotification( iProgressBuffer, iStatus );

    SetActive();

    }

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

// CMsgConnManager::StartConnection