/*

* 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: The view class for ConnTest

* Implements command handling, menu initializing and view activation

*

*/

// INCLUDE FILES

#include <aknViewAppUi.h>

#include <akntitle.h>

#include <avkon.hrh>

#include <AknGlobalNote.h>

#include <ConnTest.rsg>

#include "ConnTestView.h"

#include "ConnTestContainer.h"

#include "CustomPrefsItemList.h"

#include "CustomPrefsData.h"

#include "SettingItemList.h"

#include "SettingData.h"

#include "SocketsEngine.h"

#include "Utils.h"

#include <wlanmgmtclient.h>

#include "ConnTestAppUi.h"

// CONSTANTS

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

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

// CConnTestView::CConnTestView(const TUid aViewId)

// Constructor

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

//

CConnTestView::CConnTestView(const TUid aViewId)

    : iViewId(aViewId), iWaiter( NULL )

    {

    RDebug::Print(_L("ConnTest: CConnTestView::CConnTestView( aViewId )"));

    }

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

// CConnTestView::CConnTestView(const TUid aViewId,

//                              CSettingData* aSettings,

//                              CCustomPrefsData* aCustomPrefs)

// Constructor

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

//

CConnTestView::CConnTestView(const TUid aViewId, CSettingData* aSettings, CCustomPrefsData* aCustomPrefs)

    : iViewId(aViewId), iSettingData(aSettings), iCustomPrefsData(aCustomPrefs), iWaiter( NULL )

    {

    RDebug::Print(_L("ConnTest: CConnTestView::CConnTestView( aViewId, aSettings, aCustomPrefs )"));

    }

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

// CConnTestView::ConstructL()

// EPOC two-phased constructor

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

//

void CConnTestView::ConstructL()

    {

    RDebug::Print(_L("ConnTest: CConnTestView::ConstructL"));

    BaseConstructL( R_CONNTEST_VIEW1 );

    iSendData = HBufC8::NewL(KMaxSendBuffer);

    RDebug::Print(_L("ConnTest: CConnTestView::ConstructL iWlanMgmtClient"));

    TRAPD(err,iWlanMgmtClient = CWlanMgmtClient::NewL());

    if (err == KErrNone)

        {

        iSupportsWlan = ETrue;

        }

    else

        {

        iSupportsWlan = EFalse;

        }

    }

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

// CConnTestView::~CConnTestView()

// Destructor

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

//

CConnTestView::~CConnTestView()

    {

    RDebug::Print(_L("ConnTest: CConnTestView::~CConnTestView"));

    if ( iContainer )

        {

        AppUi()->RemoveFromViewStack( *this, iContainer );

        }

    delete iSocketsEngine;

    delete iContainer;

    delete iSettingsListBox;

    delete iCustomPrefsListBox;

    //    delete iSettingData; owned now by CConnTestDocument

    if(iSendData)

        {

        delete iSendData;

        iSendData = NULL;   

        if ( iSupportsWlan && iWlanMgmtClient )

            {

            iWlanMgmtClient->CancelNotifications();

            delete iWlanMgmtClient;

            }           

        }

    }

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

// TUid CConnTestView::Id()

// Return id of this view instance

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

//

TUid CConnTestView::Id() const

    {

    //return KViewId;

    return iViewId;

    }

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

// CConnTestView::HandleCommandL(TInt aCommand)

// Command handler

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

//

void CConnTestView::HandleCommandL(TInt aCommand)

    {   

    switch ( aCommand )

        {

        case EAknSoftkeyExit:

            iSocketsEngine->Cancel();

            AppUi()->HandleCommandL(EEikCmdExit);

            break;

        case EAknSoftkeyOk:       

        case EAknSoftkeyBack:

            // Same actions for OK and Back keys. These are called

            // from settings or Ext Connection Preferences view.

            if (iActiveContainer == ESettingsContainer)

                {

                // Store settings and update the values

                // in socket engine.

                iSettingsListBox->StoreSettingsL();

                iSocketsEngine->SetConnectionData(iSettingData);

                }

            else // ECustomPrefsContainer

                {

                // Store the custom preferences and update the values

                // in socket engine.

                iCustomPrefsListBox->StoreSettingsL();

                iSocketsEngine->SetCustomPrefsData(iCustomPrefsData);                

                }

            SwapContainerL(EOutputContainer);

            break;

        case EConnTestCmdStartInterface:

            // Start the interface

            iSocketsEngine->StartInterfaceL(CSocketsEngine::EAskIap);

            break;

        case EConnTestCmdStartSnap:

            //start connection with snap

            iSocketsEngine->StartConnWithSnapL();

            break;

        case EConnTestCmdStartInterfaceExtConnPrefs:

            // Start the interface using Extended Connection Preferences

            RDebug::Print(_L("ConnTest: Start ExtConnPrefs"));

            iSocketsEngine->StartInterfaceL(CSocketsEngine::EExtPrefs);

            break;

        case EConnTestCmdStartInternet:

            // Start the interface using Extended Connection Preferences

            RDebug::Print(_L("ConnTest: Start Internet"));

            iSocketsEngine->StartInterfaceL(CSocketsEngine::EExtPrefsInternet);

            break;

        case EConnTestCmdStartInterfaceNoPrefs:

            // Start the interface

            iSocketsEngine->StartInterfaceL(CSocketsEngine::ENoPrefs);

            break;

        case EConnTestCmdStartByNetworkId:

            // Start the interface with network id

            iSocketsEngine->StartInterfaceL(CSocketsEngine::ENetworkId);

            break;

        case EConnTestCmdStopInterface:

            // Stop the interface with RConnection::Stop

            iSocketsEngine->StopInterfaceL();

            break;

        case EConnTestCmdStartForClose:

            // Stop the interface with RConnection::Close

            iSocketsEngine->StartCloseInterfaceL();

            break;

        case EConnTestCmdCloseInterface:

            // Stop the interface with RConnection::Close

            iSocketsEngine->CloseInterface();

            break;

        case EConnTestCmdConnectionInfo:

            // Print information about the active connections

            iSocketsEngine->ConnectionInfoL();

            break;

        case EConnTestCmdInterfaceInfo:

            // Print information about interfaces. Show wait note here,

            // because this usually takes a while.

            {            

            TInt permanentNoteId;

            CAknGlobalNote* globalNote = CAknGlobalNote::NewL();

            CleanupStack::PushL(globalNote);

            globalNote->SetSoftkeys(R_AVKON_SOFTKEYS_EMPTY);

            permanentNoteId = globalNote->ShowNoteL( EAknGlobalWaitNote, _L("Fetching information...") );

            iSocketsEngine->InterfaceInfoL();

            globalNote->CancelNoteL(permanentNoteId);

            CleanupStack::PopAndDestroy(globalNote); // globalNote

            }

            break;

        case EConnTestCmdClearOutputWindow:

            // Clear the output window

            iContainer->ClearOutputWindow();

            break;

        case EConnTestCmdSettings:

            // Display settings list

            SwapContainerL(ESettingsContainer);

            break;

        case EConnTestCmdSetCustomPrefs:

            // Display Custom Preferences list

            SwapContainerL(ECustomPrefsContainer);

            break;

        case EConnTestCmdMigrate:

            iSocketsEngine->Migrate();

            break;

        case EConnTestCmdIgnore:

            iSocketsEngine->Ignore();

            break;

        case EConnTestCmdAccept:

            iSocketsEngine->AcceptCarrier();

            break;

        case EConnTestCmdReject:

            iSocketsEngine->RejectCarrier();

            break;

        case EConnTestCmdConnect:

            // Connect the socket

            iSocketsEngine->ConnectL();

            break;

        case EConnTestCmdDisconnect:

            // Disconnect the socket but do not stop the interface

            iSocketsEngine->Disconnect();

            break;

        case EConnTestCmdListen:

            // Create TCP socket that listens and receives raw TCP data

            iSocketsEngine->ListenL();

            break;

        case EConnTestCmdSendHttpGet:

            {

            // Send HTTP Get

            iSocketsEngine->SendHttpRequestOverSocketL(EFalse, EFalse);

            }

            break;

        case EConnTestCmdSendPerformanceHttpGet:

            {

            // Send HTTP Get

            if (iSocketsEngine->GetSocketEngineState() == CSocketsEngine::EConnected)

                {

                iSocketsEngine->SendHttpRequestOverSocketL(EFalse, ETrue);

                }

            }

            break;

        case EConnTestCmdSendHttpPost:

            {

            // Send HTTP Post

            iSocketsEngine->SendHttpRequestOverSocketL(ETrue, ETrue);

            }

            break;

        case EConnTestCmdSendRawData:

            // Send datagrams

            CreateDataPacket();

            SendDataL();

            break;

        case EConnTestCmdHttpFrameworkGet:

            // Send HTTP request (for testing the HTTP framework)

            iSocketsEngine->SendHttpFrameworkRequestL(EFalse, EFalse, EFalse);

            break;

        case EConnTestCmdHttpFrameworkPost:

            // Send HTTP request (for testing the HTTP framework)

            iSocketsEngine->SendHttpFrameworkRequestL(ETrue, EFalse, EFalse);

            break;

        case EConnTestCmdHttpFrameworkSecureGet:

            // Send HTTP request (for testing the HTTP framework)

            iSocketsEngine->SendHttpFrameworkRequestL(EFalse, EFalse, ETrue);

            break;

        case EConnTestCmdHttpFrameworkPerformanceGet:

            // Send HTTP request (for testing the HTTP framework)

            iSocketsEngine->SendHttpFrameworkRequestL(EFalse, ETrue, EFalse);

            break;

        case EConnTestCmdHttpFrameworkPerformancePost:

            // Send HTTP request (for testing the HTTP framework)

            iSocketsEngine->SendHttpFrameworkRequestL(ETrue, ETrue, EFalse);

            break;

        case EConnTestCmdCancel:

            // Cancel ongoing operation

            iSocketsEngine->Cancel();

            break;

        case EConnTestCmdConnectionPrefsIap:

            // Write IapId value to ConnectionPreferences table

            TRAPD(err, Utils::SetConnectionPrefsIapL());

            if(err)

                {

                if(err == KErrNotFound)

                    {

                    iContainer->ErrorNotify(_L("Non-existing id"), err);

                    }

                else

                    {

                    iContainer->ErrorNotify(_L("Setting id failed"), err);

                    }

                }

            break;

        case EConnTestCmdTimeoutLastSocketActivity:

            // Set LastSocketActivity

            TRAPD(err2, Utils::SetTimeoutsL(EConnTestCmdTimeoutLastSocketActivity));

            if(err2)

                {

                iContainer->ErrorNotify(_L("Failed to set timer"), err2);

                }        

            break;

        case EConnTestCmdTimeoutLastSocketClosed:

            // Set LastSocketClosed

            TRAPD(err3, Utils::SetTimeoutsL(EConnTestCmdTimeoutLastSocketClosed));

            if(err3)

                {

                iContainer->ErrorNotify(_L("Failed to set timer"), err3);

                }        

            break;

        case EConnTestCmdTimeoutLastSessionClosed:

            // Set LastSessionClosed

            TRAP(err, Utils::SetTimeoutsL(EConnTestCmdTimeoutLastSessionClosed));

            if(err)

                {

                iContainer->ErrorNotify(_L("Failed to set timer"), err);

                }        

            break;

        case EConnTestCmdWLANQoSVoice:

            iSocketsEngine->SetWLANQoS(7);

            break;

        case EConnTestCmdWLANQoSVideo:

            iSocketsEngine->SetWLANQoS(5);

            break;

        case EConnTestCmdWLANQoSBestEffort:

            iSocketsEngine->SetWLANQoS(3);

            break;

        case EConnTestCmdWLANQoSBackground:

            iSocketsEngine->SetWLANQoS(1);

            break;

        case EConnTestCmdWLANQoSNone:

            iSocketsEngine->SetWLANQoS(0);

            break;

            //

            // WLAN COMMANDS

            // 

        case EConnTestWlanAvailableIaps:

            {

            if (!iSupportsWlan) { iContainer->PrintNotify(_L("WLAN not supported\n")); break; }

            iWaiter = new (ELeave) CConnTestViewWaiter( iWlanMgmtClient, *this, EConnTestWaitTypeAvailableIaps );

            iWaiter->ConstructL();

            iWaiter->IssueRequest();

            }

            break;

        case EConnTestWlanScan:

            {

            if (!iSupportsWlan) { iContainer->PrintNotify(_L("WLAN not supported\n")); break; }

            iWaiter = new (ELeave) CConnTestViewWaiter( iWlanMgmtClient, *this, EConnTestWaitTypeScan );

            iWaiter->ConstructL();

            iWaiter->IssueRequest();

            }

            break;

        case EConnTestWlanGetSsid:

            {

            if (!iSupportsWlan) { iContainer->PrintNotify(_L("WLAN not supported\n")); break; }

            TWlanSsid ssid;

            TInt ret = iWlanMgmtClient->GetConnectionSsid( ssid );

            if( ret )

                {

                RDebug::Print( _L( "ConnTest: Error: %d" ), ret );

                break;

                }

            RDebug::Print( _L( "ConnTest: SSID = %S" ), &ssid );

            TBuf8<64> text;

            text.Append(_L8("SSID: "));

            text.Append(ssid);

            text.Append(_L8("\n"));

            iContainer->PrintNotify(text);

            }

            break;

        case EConnTestWlanGetBssid:

            {

            if (!iSupportsWlan) { iContainer->PrintNotify(_L("WLAN not supported\n")); break; }

            TWlanBssid bssid;

            TInt ret = iWlanMgmtClient->GetConnectionBssid( bssid );

            if( ret )

                {

                RDebug::Print( _L( "ConnTest: Error: %d" ), ret );

                break;

                }

            RDebug::Print( _L( "ConnTest: BSSID = %S" ), &bssid );

            TBuf8<64> text;

            text.AppendFormat(_L8("BSSID: %02X:%02X:%02X:%02X:%02X:%02X\n"), bssid[0], bssid[1], bssid[2], bssid[3],bssid[4], bssid[5] );

            iContainer->PrintNotify(text);

            }

            break;

        case EConnTestWlanGetRssi:

            {

            if (!iSupportsWlan) { iContainer->PrintNotify(_L("WLAN not supported\n")); break; }

            TInt32 rssi32;

            TInt ret = iWlanMgmtClient->GetConnectionSignalQuality( rssi32 );

            if( ret )

                {

                RDebug::Print( _L( "ConnTest: Error: %d" ), ret );

                break;

                }

            RDebug::Print( _L( "ConnTest: RSSI = %d" ), rssi32 );

            TInt8 rssi8 = static_cast<TInt8>(rssi32);

            TBuf8<64> text;

            text.AppendFormat(_L8("RSSI: %d\n"), rssi8);

            iContainer->PrintNotify(text);

            }

            break;

        case EConnTestWlanGetConnMode:

            {

            if (!iSupportsWlan) { iContainer->PrintNotify(_L("WLAN not supported\n")); break; }

            TWlanConnectionMode connMode;

            TInt ret = iWlanMgmtClient->GetConnectionMode( connMode );

            if( ret )

                {

                RDebug::Print( _L( "ConnTest: Error: %d" ), ret );

                break;

                }

            RDebug::Print( _L( "ConnTest: ConnectionMode = %d" ), connMode );

            TBuf8<64> text;

            text.Append(_L8("Mode: "));

            switch( connMode )

                {

                case EWlanConnectionModeNotConnected:

                    text.Append(_L8("Not Connected"));

                    break;

                case EWlanConnectionModeInfrastructure:

                    text.Append(_L8("Infrastructure"));

                    break;

                case EWlanConnectionModeAdhoc:

                    text.Append(_L8("Ad hoc"));

                    break;

                case EWlanConnectionModeSecureInfra:

                    text.Append(_L8("SecureInfra"));

                    break;

                case EWlanConnectionModeSearching:

                    text.Append(_L8("Searching"));

                    break;

                }

            text.Append(_L8("\n"));

            iContainer->PrintNotify(text);

            }

            break;

        case EConnTestWlanGetSecurityMode:

            {

            if (!iSupportsWlan) { iContainer->PrintNotify(_L("WLAN not supported\n")); break; }

            TWlanConnectionSecurityMode securityMode;