/*

 * Copyright (c) 2006-2009 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: CSocketsEngine implements an engine for connection

 * component checking: Interface opening/closing, connecting,

 * sending/receiving data, etc.

 * CSocketsEngine is an active object

 *

 */

// INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_sock_partner.h>

#include <es_enum_internal.h>

#endif

#include <eikgted.h>

#include <in_sock.h>

#include <e32svr.h>

#include <es_enum.h>

#include <commdb.h>

#include <in_iface.h>

#include <apgcli.h>

#include <apaid.h>

#include "SocketsEngine.h"

#include "TimeOutTimer.h"

#include "SocketsRead.h"

#include "SocketsWrite.h"

#include "ProgressNotifier.h"

#include "ConnTest.pan"

#include "uinotify.h"

#include "HttpHandler.h"

#include "SettingData.h"

#include "CustomPrefsData.h"

#include "Utils.h"

#include "SendTimer.h"

#include "alractiveobject.h"

#include <hal.h>

#include <hal_data.h>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <cmapplicationsettingsui.h>

// CONSTANTS

const TInt KTimeOut = 120000000; // 2 minutes time-out

_LIT(KDefaultServerName, "127.0.0.1");

const TInt KDefaultPortNumber = 25;

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

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

// CSocketsEngine::NewL(MUINotify& aConsole)

// EPOC two phased constructor

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

//

CSocketsEngine* CSocketsEngine::NewL( MUINotify& aConsole )

    {

    CSocketsEngine* self = CSocketsEngine::NewLC( aConsole );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSocketsEngine::NewLC(MUINotify& aConsole)

// EPOC two phased constructor

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

//

CSocketsEngine* CSocketsEngine::NewLC( MUINotify& aConsole )

    {

    CSocketsEngine* self = new (ELeave) CSocketsEngine( aConsole );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CSocketsEngine::CSocketsEngine(MUINotify& aConsole)

// EPOC constructor

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

//

CSocketsEngine::CSocketsEngine( MUINotify& aConsole ) :

    CActive( EPriorityStandard ), iConsole( aConsole ), iPort(

            KDefaultPortNumber ), iServerName( KDefaultServerName )

    {

    iStartTime = 0;

    }

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

// CSocketsEngine::~CSocketsEngine()

// Destructor

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

//

CSocketsEngine::~CSocketsEngine()

    {

    Cancel();

    if (iProgressNotifier)

        {

        iProgressNotifier->Cancel();

        }

    delete iSocketsRead;

    iSocketsRead = NULL;

    delete iSocketsWrite;

    iSocketsWrite = NULL;

    delete iProgressNotifier;

    iProgressNotifier = NULL;

    delete iTimer;

    iTimer = NULL;

    delete iSendTimer;

    delete iHttpClient;

    iHttpClient = NULL;

    if (iData)

        {

        delete iData;

        iData = NULL;

        }

    //delete pointer to mobility API

    if (iMobility)

        {

        delete iMobility;

        iMobility = NULL;

        }

    delete iExtPrefs;

    delete iPrefsList;

    // Note! Closing order matters. Panic occurs if the

    // closing is made in different order. 

    iConnection.Close();

    iSocket.Close();

    iSocketServ.Close();

    }

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

// CSocketsEngine::ConstructL()

// EPOC two phased constructor

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

//

void CSocketsEngine::ConstructL()

    {

    ChangeStatus( EInterfaceDown );

    iData = HBufC8::NewL( KMaxSendBuffer);

    // Start a timer

    iTimer = CTimeOutTimer::NewL( EPriorityHigh, *this );

    CActiveScheduler::Add( this );

    // Open channel to Socket Server

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

    // Open connection

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

    // Create socket read and write active objects

    iSocketsRead = CSocketsRead::NewL( iConsole, iSocket, *this );

    iSocketsWrite = CSocketsWrite::NewL( iConsole, iSocket, *this );

    // Create interface notification active object

    iProgressNotifier = CProgressNotifier::NewL( iConnection, *this );

    iProgressNotifier->StartNotify();

    //

    // HTTP framework initialization

    //

    iHttpClient = CHttpClient::NewL( iConsole );

    iHttpClient->SetHttpConnectionInfoL( ETrue, iConnection, iSocketServ );

    // Timer for sending multiple packets

    if (!iSendTimer)

        {

        iSendTimer = CSendTimer::NewL( EPriorityHigh, this );

        }

    iUseTTime = EFalse;

    TInt freq;

    TInt err = HAL::Get( HAL::EFastCounterFrequency, freq );

    if (err != KErrNone || freq == 0)

        {

        iUseTTime = ETrue;

        }

    //set mobility API flag to false

    iIsRegisteredToMobAPI = EFalse;

    SetSocketEngineConnType( ETypeUnknown );

    iExtPrefs = new (ELeave) TExtendedConnPref;

    iPrefsList = TConnPrefList::NewL();

    }

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

// CSocketsEngine::GetSocketEngineState()

// Return the current state of the socket engine.

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

//

CSocketsEngine::TSocketsEngineState CSocketsEngine::GetSocketEngineState()

    {

    return iEngineStatus;

    }

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

// CSocketsEngine::GetSocketEngineRoamingState()

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

// 

CSocketsEngine::TRoamingUIState CSocketsEngine::GetSocketEngineRoamingState()

    {

    return iRoamingState;

    }

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

// CSocketsEngine::GetMobilityAPI()

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

// 

CALRActiveObject* CSocketsEngine::GetMobilityAPI()

    {

    return iMobility;

    }

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

// CSocketsEngine::GetSocketEngineConnType()

// Return the current connection type of the socket engine.

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

//

CSocketsEngine::TSocketsEngineStartType CSocketsEngine::GetSocketEngineConnType()

    {

    return iSockEngineStartType;

    }

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

// CSocketsEngine::SetSocketEngineConnType()

// Set the current conn type of the socket engine.

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

//

void CSocketsEngine::SetSocketEngineConnType( const CSocketsEngine::TSocketsEngineStartType aConnStartType )

    {

    iSockEngineStartType = aConnStartType;

    }

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

// CSocketsEngine::StartConnWithSnapL()

// Start the connection with snap

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

//

void CSocketsEngine::StartConnWithSnapL( TBool aConnect )

    {

    if (iEngineStatus == EConnected || iEngineStatus == EInterfaceUp)

        {

        return;

        }

    //start the connection  dialog

    CCmApplicationSettingsUi* settings = CCmApplicationSettingsUi::NewL();

    CleanupStack::PushL( settings );

    TCmSettingSelection selection;

    settings->RunApplicationSettingsL( selection );

    CleanupStack::PopAndDestroy( settings );

    switch (selection.iResult)

        {

        case CMManager::EConnectionMethod:

            {

            // start connection with Iap Id

            iPrefs.SetIapId( selection.iId );

            iPrefs.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

            StartTickCount();

            iConnection.Start( iPrefs, iStatus );

            break;

            }

        case CMManager::EDestination:

            {

            TConnSnapPref pref;

            pref.SetSnap( selection.iId );

            StartTickCount();

            //start connection with snap Id

            iConnection.Start( pref, iStatus );

            //Set connection type as Snap	

            SetSocketEngineConnType( ESnap );

            break;

            }

        case CMManager::EAlwaysAsk:

            {

            // For testing start without preferences

            StartTickCount();

            iConnection.Start( iStatus );

            ChangeStatus( EStartingInterface );

            iConnectAfterStartup = ETrue;

            SetActive();

            return;

            }

        default:

            {

            RDebug::Print( _L("ConnTest: Invalid selection"));

            return;

            }

        }

    ChangeStatus( EStartingInterface );

    //specify if a connection is needed after interface startup(

    iConnectAfterStartup = aConnect;

    SetActive();

    }

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

// CSocketsEngine::StartInterfaceL(TBool aConnect)

// Start interface

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

//

void CSocketsEngine::StartInterfaceL( TSocketsEngineStartType aStartType,

        TBool aConnect )

    {

    RDebug::Print( _L("ConnTest: StartInterfaceL( Start type = %d )"), aStartType );

    if (iEngineStatus == EConnected || iEngineStatus == EInterfaceUp)

        {

        RDebug::Print( _L("ConnTest: Selection cancelled!"));

        return;

        }

    SetSocketEngineConnType( aStartType );

    if (aStartType == EAskIap)

        {

        // Get IAP id

        TUint32 iapId;

        TInt popupOk = Utils::AskIapIdL( iapId );

        if (!popupOk)

            {

            RDebug::Print( _L("ConnTest: Selection cancelled!"));

            return;

            }

        RDebug::Print( _L("ConnTest: Selected IAP id=%d"), iapId );

        // Create overrides

        iPrefs.SetIapId( iapId );

        iPrefs.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

        }

    else if (aStartType == ENetworkId)

        {

        // Get network id

        TUint32 nwkId;

        TInt popupOk = Utils::AskNetworkIdL( nwkId );

        if (!popupOk)

            {

            RDebug::Print( _L("ConnTest: Selection cancelled!"));

            return;

            }

        RDebug::Print( _L("ConnTest: Selected Network id=%d"), nwkId );

        // Create overrides

        iPrefs.SetNetId( nwkId );

        iPrefs.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

        }

    // Start the timer after the dialogs

    StartTickCount();

    // ...And now there are few different kinds of iConnection.Start() functions to call...

    if (aStartType == EExtPrefs)

        {

        iPrefsList->AppendL( iExtPrefs );

        iConnection.Start( *iPrefsList, iStatus );

        iPrefsList->Remove( 0 );

        }

    else if (aStartType == EExtPrefsInternet)

        {

        TExtendedConnPref* tmpExtPrefs = new (ELeave) TExtendedConnPref;

        tmpExtPrefs->SetSnapPurpose( CMManager::ESnapPurposeInternet );

        iPrefsList->AppendL( tmpExtPrefs );

        iConnection.Start( *iPrefsList, iStatus );

        iPrefsList->Remove( 0 );

        delete tmpExtPrefs;

        }

    else if (aStartType == ENoPrefs)

        {

        iConnection.Start( iStatus );

        }

    else // (aStartType == EAskIap || aStartType == ENetworkId) - Other values aren't used.

        {

        iConnection.Start( iPrefs, iStatus );

        }

    ChangeStatus( EStartingInterface );

    iConnectAfterStartup = aConnect;

    SetActive();

    }

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

// CSocketsEngine::RegisterToMobilityAPI(TBool aConnect)

// Register to mobility API

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

//

void CSocketsEngine::RegisterToMobilityAPIL()

    {

    if (iEngineStatus == EConnected || iEngineStatus == EInterfaceUp)

        {

        if (!iIsRegisteredToMobAPI)

            {

            iConsole.PrintNotify( _L("RegisterToMobilityAPI\n"));

            //create the listener active object

            iMobility = CALRActiveObject::NewL( iConsole,

                    (MMobilityProtocolResp*)this );

            iMobility->OpenL( iConnection );

            iIsRegisteredToMobAPI = ETrue;

            }

        }

    else

        {

        iConsole.PrintNotify( _L("Could not register\n"));

        }

    }

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

// CSocketsEngine::UnRegisterToMobilityAPI(TBool aConnect)

// UnRegister from mobility API

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

//

void CSocketsEngine::UnRegisterFromMobilityAPI()

    {

    if (iIsRegisteredToMobAPI && iMobility) //&& 

    //(iEngineStatus == EConnected || iEngineStatus == EInterfaceUp || iEngineStatus == EConnecting))

        {

        delete iMobility;

        iMobility = NULL;

        iConsole.PrintNotify( _L("Unregister MobilityAPI\n"));

        }

    iIsRegisteredToMobAPI = EFalse;

    }

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

// CSocketsEngine::Error()

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

// 

void CSocketsEngine::Error( TInt aError )

    {

    TBuf8<64> text;

    text.AppendFormat( _L8("MobilityError: %d\n"), aError );

    iConsole.PrintNotify( text );

    UnRegisterFromMobilityAPI();

    iRoaming = ERoamingOff;

    }

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

// CSocketsEngine::PreferredCarrierAvailable()

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

// 

void CSocketsEngine::PreferredCarrierAvailable( TAccessPointInfo aOldAP,

        TAccessPointInfo aNewAP,

        TBool aIsUpgrade,

        TBool aIsSeamless )

    {

    // silence warnings

    aOldAP = aOldAP;

    aIsUpgrade = aIsUpgrade;

    aIsSeamless = aIsSeamless;

    TBuf8<64> text;

    if (iRoaming == ERoamingAutomatic)

        {

        text.AppendFormat( _L8("Migrating to %i\n"), aNewAP.AccessPoint() );

        iMobility->MigrateToPreferredCarrier();

        iRoamingState = EIdle;

        }

    else if (iRoaming == ERoamingManual)

        {

        text.AppendFormat( _L8("Preferred IAP %i Available\n"), aNewAP.AccessPoint() );

        iRoamingState = EPendingPreferredCarrier;

        iConsole.PopupNotify( _L("Migrate or Ignore available"));

        }

    else

        {

        text.AppendFormat( _L8("Unexpected PreferrredCarrier %i\n"), aNewAP.AccessPoint() );

        iRoamingState = EIdle;

        iMobility->IgnorePreferredCarrier();

        }

    iConsole.PrintNotify( text );

    }

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

// CSocketsEngine::NewCarrierActive()

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

// 

void CSocketsEngine::NewCarrierActive( TAccessPointInfo aNewAP,

        TBool aIsSeamless )

    {

    // silence warning

    aIsSeamless = aIsSeamless;

    TBuf8<64> text;

    if (iRoaming == ERoamingAutomatic)

        {

        iRoamingState = EIdle;

        iMobility->NewCarrierAccepted();

        }

    else if (iRoaming == ERoamingManual)

        {

        text.AppendFormat( _L8("IAP %i pending accept\n"), aNewAP.AccessPoint() );

        iRoamingState = EPendingNewCarrierActive;

        iConsole.PopupNotify( _L("Accept or Reject available"));

        }

    else

        {

        iRoamingState = EIdle;