/*

* 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:  Represents a connection

*

*

*/

// INCLUDE FILES

#include <stdlib.h>

#include <NIFVAR.H>

#include <StringLoader.h>

#include <ConnectionMonitorUi.rsg>

#include <avkon.rsg>

#include <AknUtils.h>

#include <apgcli.h>

#include "ConnectionMonitorUiLogger.h"

#include "ConnectionInfoBase.h"

#include "ActiveWrapper.h"

// CONSTANTS

const TUint KUpArrowChar = 0x2191; ///< ASCII code of UpArrow

const TUint KDownArrowChar = 0x2193; ///< ASCII code of DownArrow

const TUint KBannedServerUID = 0x101fd9c5; // Banned DHCP server UID

const TInt KFeedsServerUid         = 0x1020728E;

const TInt KDownloadMgrServerUid   = 0x10008D60;

const TInt KMessagingServerUid     = 0x1000484b;

const TInt KJavaVMUid              = 0x102033E6;

const TInt KSUPLServerUid          = 0x102073CA;

LOCAL_D const TInt KStringsGranularity = 5;

_LIT( KMrouterName, "mRouter"); ///< see CheckMrouteIap

_LIT( KEmpty, "");      ///< Empty string

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

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

// CConnectionInfoBase::~CConnectionInfoBase

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

//

CConnectionInfoBase::~CConnectionInfoBase()

    {

    delete iDetailsArray;

    delete iAppNames;

    }

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

// CConnectionInfoBase::CConnectionInfoBase

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

//

CConnectionInfoBase::CConnectionInfoBase(

                           TInt aConnectionId,

                           RConnectionMonitor* const aConnectionMonitor,

                           TConnMonBearerType aConnectionBearerType,

                           CActiveWrapper* aActiveWrapper ) :

    iConnectionMonitor( aConnectionMonitor ), 

    iStartTime( NULL ),

    iDeletedFromCMUI( EFalse ),

    iActiveWrapper( aActiveWrapper )

    {

    CMUILOGGER_WRITE( "CConnectionInfoBase constuctor - start " );

    iConnectionStatus = EConnectionUninitialized;

    iConnectionId = aConnectionId;

    iConnectionBearerType = aConnectionBearerType;

    iLastSpeedUpdate.UniversalTime();

    CMUILOGGER_WRITE( "CConnectionInfoBase constuctor - end " );

    }

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

// CConnectionInfoBase::ConstructL

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

//

void CConnectionInfoBase::ConstructL()

    {

    CMUILOGGER_ENTERFN( "CConnectionInfoBase::ConstructL() start" );

    if ( iConnectionBearerType >= EBearerExternalCSD )

        {

        StringLoader::Load( iConnectionName,

                            R_QTN_CMON_ITEM_CONN_NAME_MODEM );

        }

    else

        {

        iActiveWrapper->StartGetStringAttribute( iConnectionId,

                                                 iConnectionMonitor,

                                                 KIAPName,

                                                 iConnectionName );

        TInt err( iActiveWrapper->iStatus.Int() );

        CMUILOGGER_WRITE_F( "CConnectionInfoBase::ConstructL() status: %d",

                            err );

        CMUILOGGER_WRITE_F( "iConnectionName : %S", &iConnectionName );

        CMUILOGGER_WRITE_F( "iConnectionId : %d", iConnectionId );

        CMUILOGGER_WRITE_F( "iConnectionBearerType : %d", 

                            ( TInt )iConnectionBearerType );

        if ( err != KErrNone )

            {

            User::Leave( err );

            }

        }

    if ( !iAppNames )

        {

        iAppNames = new( ELeave ) CDesCArrayFlat( KStringsGranularity );

        }

    StatusChangedL();

    if ( GetStatus() == EConnectionSuspended )

        {

        InitializeConnectionInfoL();

        }

    CMUILOGGER_LEAVEFN( "CConnectionInfoBase::ConstructL() end" );

    }

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

// CConnectionInfoBase::StatusChangedL

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

//

void CConnectionInfoBase::StatusChangedL()

    {

    CMUILOGGER_WRITE( "CConnectionInfoBase::StatusChangedL() start" );

    RefreshConnectionStatus();

    switch ( iConnectionStatus )

        {

        case EConnectionCreated:

            {

            InitializeConnectionInfoL();

            break;

            }

        case EConnectionSuspended:

            {

            RefreshDetailsL();

            if ( !iDetailsArray )

                {

                ToArrayDetailsL();

                }

            RefreshDetailsArrayL();

            break;

            }

        case EConnectionClosing:

        case EConnectionClosed:

        case EConnectionUninitialized:

        	{

        	if ( iDetailsArray ) // if there is details array

        	    {

        	    RefreshDetailsArrayL();

        	    }

            break;

        	}

        case EConnectionCreating:

        default :

            {

            break;

            }

        }

    RefreshConnectionListBoxItemTextL();

    CMUILOGGER_WRITE( "CConnectionInfoBase::StatusChangedL() end" );

    }

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

// CConnectionInfoBase::IsAlive

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

//

TBool CConnectionInfoBase::IsAlive() const

    {

    TBool alive( EFalse );

    if ( ( iConnectionStatus == EConnectionSuspended ) ||

         ( iConnectionStatus == EConnectionCreated ) )

        {

        alive = ETrue;

        }

    return alive;

    }

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

// CConnectionInfoBase::IsSuspended

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

//

TBool CConnectionInfoBase::IsSuspended() const

    {

    TBool suspended( EFalse );

    if ( iConnectionStatus == EConnectionSuspended )

        {

        suspended = ETrue;

        }

    return suspended;

    }    

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

// CConnectionInfoBase::GetConnectionId

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

//

CDesCArrayFlat* CConnectionInfoBase::GetDetailsArray() const

    {

    }

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

// CConnectionInfoBase::GetConnectionId

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

//

TUint CConnectionInfoBase::GetConnectionId() const

    {

    return iConnectionId;

    }

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

// CConnectionInfoBase::GetStatus

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

//

TConnectionStatus CConnectionInfoBase::GetStatus() const

    {

    return iConnectionStatus;

    }

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

// CConnectionInfoBase::GetName

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

//

HBufC* CConnectionInfoBase::GetNameLC() const

    {

    HBufC* name = iConnectionName.AllocLC();

    return name;

    }

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

// CConnectionInfoBase::GetBearerType

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

//

TConnMonBearerType CConnectionInfoBase::GetBearerType() const

    {

    return iConnectionBearerType;

    }

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

// CConnectionInfoBase::GetConnectionListBoxItemText

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

//

TPtrC CConnectionInfoBase::GetConnectionListBoxItemText() const

    {

    return iListBoxItemText;

    }

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

// CConnectionInfoBase::RefreshConnectionStatus

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

//

void CConnectionInfoBase::RefreshConnectionStatus()

    {

    TConnectionStatus connStatus( EConnectionUninitialized );

    iActiveWrapper->StartGetIntAttribute( iConnectionId,

                                          iConnectionMonitor,

                                          KConnectionStatus,

                                          ( ( TInt& )( connStatus ) ) );

    TInt err( iActiveWrapper->iStatus.Int() );

    CMUILOGGER_WRITE_F( "RefreshConnectionStatus status : %d",

                        err );

    if ( err == KErrNone )

        {

        RefreshConnectionStatus( connStatus );

        }

    else

        {

        iActiveWrapper->Cancel();

        }

    }

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

// CConnectionInfoBase::RefreshConnectionStatus

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

//

void CConnectionInfoBase::RefreshConnectionStatus(

    {

    CMUILOGGER_ENTERFN( "RefreshConnectionStatus" );

    CMUILOGGER_WRITE_F( "RefreshConnectionStatus aConnectionStatus %d",

                        ( TInt )aConnectionStatus );

    CMUILOGGER_WRITE_F( "iConnectionStatus before %d",

                        ( TInt )iConnectionStatus );

    if ( ( aConnectionStatus == KLinkLayerOpen ) ||

          ( ( aConnectionStatus == KConnectionOpen ) &&

            ( iConnectionBearerType >= EBearerExternalCSD ) ) )

        {

        CMUILOGGER_WRITE("1");

        iConnectionStatus = EConnectionCreated;

        }

        {

        CMUILOGGER_WRITE("2");        

        iConnectionStatus = EConnectionClosed;

        }

    else if ( ( ( aConnectionStatus >= KMinAgtProgress ) &&

               ( aConnectionStatus <= KConnectionOpen ) ) ||

               ( aConnectionStatus == KStartingSelection ) ||

               ( aConnectionStatus == KFinishedSelection ) ||

               ( aConnectionStatus == KConfigDaemonStartingRegistration ) ||

               ( aConnectionStatus == KConfigDaemonFinishedRegistration ) )

        // creating

        {

        CMUILOGGER_WRITE("5");

        iConnectionStatus = EConnectionCreating;

        }

    else if ( aConnectionStatus == KDataTransferTemporarilyBlocked )

        {

        CMUILOGGER_WRITE("6");

        iConnectionStatus = EConnectionSuspended;

        }

    else if ( ( iConnectionStatus == EConnectionCreated ) &&

              ( ( aConnectionStatus >= KConnectionStartingClose ) &&

                ( aConnectionStatus < KConnectionClosed ) ||  

                ( aConnectionStatus == KConfigDaemonFinishedDeregistrationStop ) || 

                ( aConnectionStatus == KConfigDaemonStartingDeregistration ) ||

                ( aConnectionStatus == KLinkLayerClosed ) ||

                ( aConnectionStatus == KConnectionUninitialised )

              ) )

        // closing

        {

        CMUILOGGER_WRITE("7");        

        iConnectionStatus = EConnectionClosing;

        }

    else if ( ( aConnectionStatus == KConnectionUninitialised ) &&

             ( iConnectionStatus == EConnectionSuspended ) )

        { // Back to created from suspended

        CMUILOGGER_WRITE("4");

        iConnectionStatus = EConnectionCreated;

        }

    else if ( aConnectionStatus == KConnectionUninitialised )

        {

        CMUILOGGER_WRITE("3");

        iConnectionStatus = EConnectionUninitialized;

        }

    else

        {

        CMUILOGGER_WRITE_F( " else iConnectionStatus  %d",

                            ( TInt )iConnectionStatus );

        CMUILOGGER_WRITE_F( "else aConnectionStatus  %d",

                            ( TInt )aConnectionStatus );

        CMUILOGGER_WRITE("else");

        }

    CMUILOGGER_WRITE_F( "iConnectionStatus after %d",

                        ( TInt )iConnectionStatus );

    CMUILOGGER_LEAVEFN( "RefreshConnectionStatus" );                                                

    }

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

// CConnectionInfoBase::RefreshSentReceivedDataL

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

//

void CConnectionInfoBase::RefreshSentReceivedDataL()

    {

    CMUILOGGER_ENTERFN( "CConnectionInfoBase::RefreshSentReceivedDataL" );

    // Downloaded

	CMUILOGGER_WRITE("Downloaded before");

    iActiveWrapper->StartGetUintAttribute( iConnectionId,

                                           iConnectionMonitor,

                                           KDownlinkData,

                                           iDownloaded );

    TInt errDownload( iActiveWrapper->iStatus.Int() );

    CMUILOGGER_WRITE_F( "Download status: %d", errDownload );

    if ( errDownload != KErrNone )

        {

        iActiveWrapper->Cancel();

        User::Leave( errDownload );

        }

   	CMUILOGGER_WRITE("Downloaded after");

    // Uploaded

	CMUILOGGER_WRITE("Uploaded before");

    iActiveWrapper->StartGetUintAttribute( iConnectionId,

                                           iConnectionMonitor,

                                           KUplinkData,

                                           iUploaded );

    TInt errUpload( iActiveWrapper->iStatus.Int() );

    CMUILOGGER_WRITE_F( "Upload status: %d", errUpload );

    if ( errUpload != KErrNone )

        {

        iActiveWrapper->Cancel();

        User::Leave( errUpload );

        }

	CMUILOGGER_WRITE("Uploaded after");

    CMUILOGGER_LEAVEFN( "CConnectionInfoBase::RefreshSentReceivedDataL" );

    }

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

// CConnectionInfoBase::RefreshTransferSpeedsL

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

//

void CConnectionInfoBase::RefreshTransferSpeedsL()

    {

    CMUILOGGER_ENTERFN( "CConnectionInfoBase::RefreshTransferSpeedsL" );

    TUint up = iUploaded;

    TUint down = iDownloaded;

    RefreshSentReceivedDataL();

    TTime now;

    now.UniversalTime();

    // 100 * 1/1000sec

    const TUint KOnesec = 1000;

    TUint diffTime = I64LOW( now.MicroSecondsFrom( iLastSpeedUpdate ).Int64() /

                                                        TInt64( 1000 ) );

    if ( iLastSpeedUpdate.Int64() == 0 )

        {

        iLastSpeedUpdate = now;

        // speed cannot be calculated at the first time

        iUpSpeed.quot = 0;

        iUpSpeed.rem = 0;

        iDownSpeed.quot = 0;

        iDownSpeed.rem = 0;

        }

    else if ( diffTime > 500 )

        // at least 1/2sec passed

        {

        // bytes/sec

        div_t upSpeed = div( ( iUploaded - up ) * KOnesec, diffTime );

        div_t downSpeed = div( ( iDownloaded - down ) * KOnesec, diffTime );

        // kbytes/sec

        iUpSpeed = div( upSpeed.quot, 1024 );

        iDownSpeed = div( downSpeed.quot, 1024 );

        iLastSpeedUpdate = now;

        }

    CMUILOGGER_LEAVEFN( "CConnectionInfoBase::RefreshTransferSpeedsL" );

    }

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

// CConnectionInfoBase::RefreshDuration

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

//

void CConnectionInfoBase::RefreshDuration()

    {

    CMUILOGGER_ENTERFN( "CConnectionInfoBase::RefreshDuration" );

    TTime now;

    now.UniversalTime();

    // passed time since connection established.

    iDuration = now.MicroSecondsFrom( iStartTime ).Int64();

    CMUILOGGER_LEAVEFN( "CConnectionInfoBase::RefreshDuration" );

    }

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

// CConnectionInfoBase::RefreshAppNamesL

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

//

TInt CConnectionInfoBase::RefreshAppNamesL()

    {

    CMUILOGGER_ENTERFN( "CConnectionInfoBase::RefreshAppNamesL" );

    TInt sharings( 0 );

if ( IsAlive() )

    {

    if ( iAppNames )

        {

        iAppNames->Reset();

        HBufC* actAppName = NULL;

        // Check whether it is an internal or external (modem) connection

        // External (modem) connections does not need application name

        if ( iConnectionBearerType < EBearerExternalCSD )

            {

            TInt count( 0 );

            TConnMonClientEnumBuf clientBuf;

            iActiveWrapper->StartGetConnSharings( iConnectionId,

                                                  iConnectionMonitor,

                                                  clientBuf );

            TInt err( iActiveWrapper->iStatus.Int() );

            CMUILOGGER_WRITE_F( "RefreshSharings status: %d", err );

            if ( !err )

                {

                count = clientBuf().iCount;

                }

            CMUILOGGER_WRITE_F( "clientBuf().iCount: %d", count );

#ifndef __WINS__ // Appl. uid is always zero in emulator

            RApaLsSession appSess;

            TApaAppInfo appInfo;

            // The connection could be shared by several applications

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

            TUint i;

            for ( i = 0; i < count; i++ )

                {

                actAppName = NULL;

                appInfo.iCaption.Zero();