/*

* Copyright (c) 2002 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:  Application UI class

*

*

*/

// INCLUDE FILES

#include <StringLoader.h>

#include <aknnotedialog.h>

#include <AknUtils.h>

#include <cmmanagerext.h>

#include <nifvar.h>

#include <ConnectionMonitorUi.rsg>

#include "ConnectionMonitorUi.hrh"

#include "ConnectionMonitorUiAppUi.h"

#include "ConnectionMonitorUiView.h"

#include "ConnectionMonitorUiDetailsView.h"

#include "ConnectionArray.h"

#include "CsdConnectionInfo.h"

#include "GprsConnectionInfo.h"

#include "WlanConnectionInfo.h"

#include "EasyWLANConnectionInfo.h"

#include "FeatureManagerWrapper.h"

#include "ActiveWrapper.h"

// CONSTANTS

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

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

// CConnectionMonitorUiAppUi::ConstructL()

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

//

void CConnectionMonitorUiAppUi::ConstructL()

    {

    CMUILOGGER_CREATE;

    CMUILOGGER_WRITE( "Constructing CConnectionMonitorUiAppUi" );

    BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible);

#ifdef RD_CONTROL_PANEL

    TBool isEmbeddedApp = IsEmbedded();

    CMUILOGGER_WRITE_F( "IsEmbedded(): %d", isEmbeddedApp );

#endif // RD_CONTROL_PANEL                                  

    iFeatureManagerWrapper = CFeatureManagerWrapper::NewL();

    TBool isWlanSupported = FeatureManager::FeatureSupported( 

                                                    KFeatureIdProtocolWlan );

   CMUILOGGER_WRITE_F( "isWlanSupported: %b", isWlanSupported );

    // connect to connection monitor engine

    CMUILOGGER_WRITE( "Connection monitor engine" );

    iMonitor.ConnectL();

    CMUILOGGER_WRITE( "Connected" );

    CMUILOGGER_WRITE( "Creating connection array" );

    iConnectionArray = new ( ELeave ) CConnectionArray();

    iConnectionArray->ConstructL();

    iActiveWrapper = CActiveWrapper::NewL(); // start ActiveWrapper

    if ( isWlanSupported )

        {

        GetEasyWlanIAPNameL();

        }

    InitializeConnectionArrayL();

    CMUILOGGER_WRITE( "Created" );

    CMUILOGGER_WRITE( "Creating main view" );

#ifdef RD_CONTROL_PANEL

    CConnectionMonitorUiView* mainView =

        new ( ELeave ) CConnectionMonitorUiView( iConnectionArray,

                                                 &iMonitor,

                                                 isEmbeddedApp,

                                                 iActiveWrapper );

#else

    CConnectionMonitorUiView* mainView =

        new ( ELeave ) CConnectionMonitorUiView( iConnectionArray,

                                                 &iMonitor,

                                                 iActiveWrapper );

#endif // RD_CONTROL_PANEL

    CleanupStack::PushL( mainView );

    CMUILOGGER_WRITE( "Constructing main view" );

    mainView->ConstructL();

    CMUILOGGER_WRITE( "Adding main view" );

    AddViewL( mainView );      // transfer ownership to CAknViewAppUi

    SetDefaultViewL( *mainView );

    iTimerObserver = this;

    CleanupStack::Pop( mainView );

    CMUILOGGER_WRITE( "Done" );

    CMUILOGGER_WRITE( "Creating details view" );

    CConnectionMonitorUiDetailsView* detailsView =

        new ( ELeave ) CConnectionMonitorUiDetailsView( iConnectionArray );

    CleanupStack::PushL( detailsView );

    CMUILOGGER_WRITE( "Constructing details view" );

    detailsView->ConstructL();

    CMUILOGGER_WRITE( "Adding details view" );

    AddViewL( detailsView );      // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( detailsView );

    CMUILOGGER_WRITE( "Done" );

    // from this point we can listen to events of RConnectionMonitor server

    iMonitor.NotifyEventL( *this );

    activateMainView = EFalse;

    }

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

// CConnectionMonitorUiAppUi::~CConnectionMonitorUiAppUi()

// Destructor

// Frees reserved resources

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

//

CConnectionMonitorUiAppUi::~CConnectionMonitorUiAppUi()

    {

    CMUILOGGER_ENTERFN( "~CConnectionMonitorUiAppUi" );

    StopTimer();

    delete iConnectionArray;

    delete iEasyWlanIAPName;

    delete iActiveWrapper;

    delete iFeatureManagerWrapper;

    // it's needed because views are still active here

    // and a call from handleforegroundevent from them

    // can cause exception in StopConnEventNotificationL

    iMonitor.CancelNotifications();

    iMonitor.Close();

    iNewConnectionIdArray.Close();

    iConnectionsWaitingFirstEvent.Close();

    CMUILOGGER_LEAVEFN( "~CConnectionMonitorUiAppUi" );

    CMUILOGGER_DELETE;

    }

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

// CConnectionMonitorUiAppUi::InitializeConnectionArrayL

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

//

void CConnectionMonitorUiAppUi::InitializeConnectionArrayL()

    {

    CMUILOGGER_ENTERFN( "InitializeConnectionArrayL" );

    CConnectionInfoBase* connectionInfo = NULL;

    TUint connectionNumber( 0 );

    TUint connectionId( 0 );

    TUint subConnectionCount;

    TUint wlanConnectionCounter( 0 );

    TUint wlanConnectionId( 0 );

    TConnMonBearerType bearerType( EBearerUnknown );

    RArray<TUint> connIds;

    RArray<TInt> bearers;

    CleanupClosePushL( connIds );

    CleanupClosePushL( bearers );

    iActiveWrapper->StartGetConnectionCount( connectionNumber, iMonitor );

    if ( !iActiveWrapper->iStatus.Int() )

        {

        CMUILOGGER_WRITE_F( "Number of connections: %d",

                            connectionNumber );

        for ( TUint i = 1; i <= connectionNumber; ++i )

            {

            iMonitor.GetConnectionInfo( i, connectionId, subConnectionCount );

            connIds.AppendL( connectionId );

            iActiveWrapper->StartGetBearerType( connectionId,

                                                iMonitor,

                                                KBearer,

                                                ( TInt& )bearerType );                                           

            CMUILOGGER_WRITE_F( "status.Int(): %d", 

                                iActiveWrapper->iStatus.Int() );

            CMUILOGGER_WRITE_F( "bearerType: %d", ( TInt )bearerType );

            bearers.AppendL( (TInt)bearerType );

            if ( bearerType == EBearerWLAN )

                {

                wlanConnectionCounter++;

                wlanConnectionId = connectionId;

                }

            }

        for ( TInt i = 0; i < connectionNumber; i++ )

            {           

            if ( bearers[i] != EBearerWLAN || wlanConnectionCounter < 2 || connIds[i] == wlanConnectionId )

                {

                TInt err;

                TRAP(err, connectionInfo = CreateConnectionInfoL( connIds[i], (TConnMonBearerType)bearers[i] ));

                if ( !err && connectionInfo )

                    {

                    CleanupStack::PushL( connectionInfo );

                    iConnectionArray->AppendL( connectionInfo );

                    CleanupStack::Pop( connectionInfo );

                    }

                else

                    {

                    iNewConnectionIdArray.Append( connIds[i] );

                    }

                }

            else

                {

                CMUILOGGER_WRITE( "Fake WLAN connection, skipping" );

                }

            }

        }

    else

        {

        CMUILOGGER_WRITE_F( "GetConnectionCount status: %d", 

                            iActiveWrapper->iStatus.Int() );

        }

    CleanupStack::Pop( &bearers );

    bearers.Close();

    CleanupStack::Pop( &connIds );

    connIds.Close();

    CMUILOGGER_LEAVEFN( "InitializeConnectionArrayL Done" );

    }

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

// CConnectionMonitorUiAppUi::EventL

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

//

void CConnectionMonitorUiAppUi::EventL(

                                       const CConnMonEventBase &aConnMonEvent )

    {

    CMUILOGGER_ENTERFN( "CConnectionMonitorUiAppUi::EventL" );

    CMUILOGGER_WRITE_F( "EventL type: %d", aConnMonEvent.EventType() );

    CConnectionInfoBase* connectionInfo = NULL;

    TInt index( 0 );

    TConnMonEvent event = ( TConnMonEvent ) aConnMonEvent.EventType();

    TInt connectionId = aConnMonEvent.ConnectionId();

    CMUILOGGER_WRITE_F( "Connection Id:  %d", connectionId );

    switch ( event )

        {

        case EConnMonCreateConnection:

            {

            CMUILOGGER_WRITE( "EConnMonCreateConnection" );

            if ( connectionId > 0 )

                {

                iConnectionsWaitingFirstEvent.AppendL( connectionId );

                }

            break;

            }

        case EConnMonDeleteConnection:

            {

            CMUILOGGER_WRITE( "EConnMonDeleteConnection" );

            TInt count = iNewConnectionIdArray.Count();

            TInt i = 0;

            TBool newConn = EFalse;

            for ( TInt cindex = 0; cindex < iConnectionsWaitingFirstEvent.Count(); cindex++ )

                {

                if ( iConnectionsWaitingFirstEvent[cindex] == connectionId )

                    {

                    newConn = ETrue;

                    iConnectionsWaitingFirstEvent.Remove(cindex);

                    break;

                    }

                }

            if ( newConn )

                {

                // Job done

                break;

                }

            while ( i < count )

                {

                if ( iNewConnectionIdArray[i] == connectionId )

                    {

                    iNewConnectionIdArray.Remove( i );

                    CMUILOGGER_WRITE_F( "Removed id %d from array", ( TUint )connectionId );

                    count--;

                    }

                else 

                    {

                    i++;

                    }

                }

            index = iConnectionArray->GetArrayIndex( connectionId );

            if ( index >= 0 )

                {

                connectionInfo = ( *iConnectionArray )[index]; 

                if ( iView->Id() == KDetailsViewId )

                    {               

                        // Mark the connection as closed and refresh details view.

                        // It will change the status there.

                        connectionInfo->RefreshConnectionStatus( KConnectionClosed );

                        connectionInfo->RefreshDetailsArrayL();                        

                    }

                else // MainView

                    {

                    TBool deleting = connectionInfo->GetDeletedFromCMUI();

                    if ( deleting )

                        {

                        ShowConnectionSummaryInformationNoteL( connectionInfo );

                        }

                    // Mark the connection as closed and update the status text. 

                    // When the timer ticks the next time the marked connection 

                    // is deleted and removed from the main view.

                    connectionInfo->RefreshConnectionStatus( KConnectionClosed );

                    connectionInfo->RefreshConnectionListBoxItemTextL();

                    }                

                CMUILOGGER_WRITE_F( "Deleted: %d", connectionId );

                }

            break;

            }

        case EConnMonConnectionStatusChange:

            {

            CMUILOGGER_WRITE( "EConnMonConnectionStatusChange" );

            TBool newConn = EFalse;

            for ( TInt cindex = 0; cindex < iConnectionsWaitingFirstEvent.Count(); cindex++ )

                {

                if ( iConnectionsWaitingFirstEvent[cindex] == connectionId )

                    {

                    newConn = ETrue;

                    iConnectionsWaitingFirstEvent.Remove(cindex);

                    break;

                    }

                }

            index = iConnectionArray->GetArrayIndex( connectionId );

            if ( newConn || ( index < 0 ) )

                {

                if ( connectionId > 0)

                    {

                    TConnMonBearerType bearerType( EBearerUnknown );

                    iActiveWrapper->StartGetBearerType( connectionId,

                                                        iMonitor,

                                                        KBearer,

                                                        ( TInt& )bearerType );  

                    CMUILOGGER_WRITE_F( "status.Int(): %d", 

                                        iActiveWrapper->iStatus.Int() );

                    CMUILOGGER_WRITE_F( "bearerType: %d", ( TInt )bearerType );

                    if ( bearerType == 0 )

                        {

                        if ( connectionId )

                            {

                            iNewConnectionIdArray.AppendL( connectionId );

                            CMUILOGGER_WRITE_F( "id %d added to array", ( TUint )connectionId );

                            break;

                            }

                        }          

                    connectionInfo = CreateConnectionInfoL( connectionId, bearerType );

                    }

                if ( connectionInfo )

                    {

                    CleanupStack::PushL( connectionInfo );

                    iConnectionArray->AppendL( connectionInfo );

                    CleanupStack::Pop( connectionInfo );                   

                    }

                }

            index = iConnectionArray->GetArrayIndex( connectionId );

            CMUILOGGER_WRITE_F( "Found index :  %d", index );

            if ( index >= 0 )

                {

                ( *iConnectionArray )[index]->StatusChangedL();

                }

            break;

            }

        case EConnMonCreateSubConnection:

        case EConnMonDeleteSubConnection:

            {

            CMUILOGGER_WRITE( "SubConnection" );

            index = iConnectionArray->GetArrayIndex( connectionId );

            if ( index >= 0)

                {

                ( *iConnectionArray )[index]->RefreshDetailsL();

                }

            break;

            }

        default:

            {

            CMUILOGGER_WRITE( "On event default" );

            break;

            }

        }

    if ( iObserver && ( index >= 0 ) )

        {

        CMUILOGGER_WRITE( "EventL calls observer" );

        iObserver->OnEventL( aConnMonEvent, index );

        }

    CMUILOGGER_LEAVEFN( "CConnectionMonitorUiAppUi::EventL" );

    }

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

// CConnectionMonitorUiAppUi::Static

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

//

CConnectionMonitorUiAppUi* CConnectionMonitorUiAppUi::Static()

    {

    return REINTERPRET_CAST( CConnectionMonitorUiAppUi*,

                             CEikonEnv::Static()->EikAppUi() );

    }

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

//  CConnectionMonitorUiAppUi::::DynInitMenuPaneL( TInt aResourceId,

//  CEikMenuPane* aMenuPane )

//  This function is called by the EIKON framework just before it displays

//  a menu pane. Its default implementation is empty, and by overriding it,

//  the application can set the state of menu items dynamically according

//  to the state of application data.

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

//

void CConnectionMonitorUiAppUi::DynInitMenuPaneL(

    TInt /*aResourceId*/, CEikMenuPane* /*aMenuPane*/ )

    {

    }

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

// CConnectionMonitorUiAppUi::HandleKeyEventL(

//     const TKeyEvent& aKeyEvent, TEventCode /*aType*/ )

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

//

TKeyResponse CConnectionMonitorUiAppUi::HandleKeyEventL(

    const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/ )

    {

    return EKeyWasNotConsumed;

    }

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

// CConnectionMonitorUiAppUi::HandleCommandL( TInt aCommand )

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

//

void CConnectionMonitorUiAppUi::HandleCommandL( TInt aCommand )

    {

    switch ( aCommand )

        {

        case EEikCmdExit:

        case EAknCmdExit:

        case EAknSoftkeyExit:

            {

            Exit();

            break;

            }

        default:

            break;

        }

    }

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

// CConnectionMonitorUiAppUi::StartConnEventNotification

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

//

void CConnectionMonitorUiAppUi::StartConnEventNotification(

                                    MActiveEventObserverInterface* aObserver )

    {

    CMUILOGGER_ENTERFN

        ( "CConnectionMonitorUiAppUi::StartConnEventNotification" );

    iObserver = aObserver;

    CMUILOGGER_LEAVEFN

        ( "CConnectionMonitorUiAppUi::StartConnEventNotification" );

    }

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

// CConnectionMonitorUiAppUi::StopConnEventNotification

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

//

void CConnectionMonitorUiAppUi::StopConnEventNotification(

                                MActiveEventObserverInterface* aObserver )

    {

    CMUILOGGER_ENTERFN

        ( "CConnectionMonitorUiAppUi::StopConnEventNotification" );

    if ( iObserver == aObserver )

        {

        iObserver = NULL;

        }

    CMUILOGGER_LEAVEFN

        ( "CConnectionMonitorUiAppUi::StopConnEventNotification" );

    }

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

// CConnectionMonitorUiAppUi::StartTimerL

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

//

void CConnectionMonitorUiAppUi::StartTimerL( const TInt aInterval )

    {

    CMUILOGGER_WRITE( "Starting timer" );

    if ( !iPeriodic )