/*

* Copyright (c) 2008 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: Handles displaying wlan dialogs

*

*/

#include <wlanmgmtcommon.h>

#include <e32std.h>

#include <utf.h>

#include <cmpluginwlandef.h>

#include <ctsydomainpskeys.h>

#include "mpmwlanquerydialog.h"

#include "mpmiapselection.h"

#include "mpmconnmonevents.h"

#include "mpmlogger.h"

// valid Wep key lengths, to check wep key format

// (wep key format depends on key length)

const TInt KConnUiUtilsWepLengthASCII5 = 5;

const TInt KConnUiUtilsWepLengthASCII13 = 13;

const TInt KConnUiUtilsWepLengthASCII29 = 29;

const TInt KConnUiUtilsWepLengthHEX10 = 10;

const TInt KConnUiUtilsWepLengthHEX26 = 26;

const TInt KConnUiUtilsWepLengthHEX58 = 58; 

// Retry count and delay for storing Easy WLAN data

const TInt KStoreRetryCount = 10;

const TInt KStoreRetryDelay = 100000;

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

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

// CMPMWlanQueryDialog::CMPMWlanQueryDialog

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

//

CMPMWlanQueryDialog::CMPMWlanQueryDialog( CMPMIapSelection&  aSession,

                                          TUint32            aWlanIapId )

  : CActive( CActive::EPriorityStandard ),

    iIapSelection( aSession ),

    iNetworkPrefs(),

    iNotifWep(),

    iWlanQueryState( EWlanNetwork ),

    iWlanIapId( aWlanIapId ),

    iEasyWlanSelected( EFalse ),

    iOverrideStatus( KErrNone ),

    iConnUiUtils( NULL ), 

    iWps( NULL ),

    iWpsReturn( WiFiProt::EWiFiOK ),

    iWpsCompleted( EFalse ),

    iRetryCount( 0 )

    {

    }

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

// CMPMWlanQueryDialog::ConstructL

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

//

void CMPMWlanQueryDialog::ConstructL()

    {

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

    CActiveScheduler::Add( this );

    iConnUiUtils = CConnectionUiUtilities::NewL();

    User::LeaveIfError( iTimer.CreateLocal() );

    }

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

// CMPMWlanQueryDialog::NewL

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

//

CMPMWlanQueryDialog* CMPMWlanQueryDialog::NewL( CMPMIapSelection&  aSession,

                                                TUint32            aWlanIapElementId )

    {

    CMPMWlanQueryDialog* self = new( ELeave ) CMPMWlanQueryDialog( aSession,

                                                                   aWlanIapElementId );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMPMWlanQueryDialog::~CMPMWlanQueryDialog

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

//

CMPMWlanQueryDialog::~CMPMWlanQueryDialog()

    {

    MPMLOGSTRING( "CMPMWlanQueryDialog::~CMPMWlanQueryDialog enters" )

    // Check if this dialog instance was not started but only added to the queue

    if ( iIapSelection.Session()->MyServer().FirstInWlanQueryQueue() != this )

        {

        MPMLOGSTRING( "CMPMWlanQueryDialog::~CMPMWlanQueryDialog, not a active delete" )

        // Close notifier and timer

        iNotifier.Close();

        iTimer.Close();

        // We're not first in the queue, thus we can just delete.

        // But remember the pointer in the array.

        iIapSelection.Session()->MyServer().RemoveFromWlanQueryQueue( this );

        MPMLOGSTRING( "CMPMWlanQueryDialog::~CMPMWlanQueryDialog exits (break)" )

        return;

        }

    // Cancel previous dialogs if any.

    Cancel();

    // Close notifier and timer

    iNotifier.Close();

    iTimer.Close();

    delete iConnUiUtils;

    delete iWps;

    // Remove self from the queue

    iIapSelection.Session()->MyServer().RemoveFromWlanQueryQueue( this );

    // Start the next query

    CMPMWlanQueryDialog* dlg = iIapSelection.Session()->MyServer().FirstInWlanQueryQueue();

    if ( dlg )

        {

        MPMLOGSTRING( "CMPMWlanQueryDialog::~CMPMWlanQueryDialog starts new dialog" )

        dlg->OfferInformation( iWlanIapId, 

                               iIapSelection.OfflineNoteResponse(),

                               iStatus.Int() );

        // In destructor we cannot let the query leave

        TRAPD( err, dlg->StartWlanQueryL(); )

        if ( err != KErrNone )

            {

            MPMLOGSTRING2( "CMPMWlanQueryDialog::~CMPMWlanQueryDialog caught Leave %d, executing RunError()", err )

            dlg->RunError( err );

            }

        }

    MPMLOGSTRING( "CMPMWlanQueryDialog::~CMPMWlanQueryDialog exits" )

    }

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

// CMPMWlanQueryDialog::DoCancel

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

//

void CMPMWlanQueryDialog::DoCancel()

    {

    MPMLOGSTRING2( "CMPMWlanQueryDialog::DoCancel state %d", iWlanQueryState )

    if ( iWlanQueryState == EOffline )

        {

        iNotifier.CancelNotifier( KUidCOfflineWlanNoteDlg );

        }

    else if ( iWlanQueryState == EWlanNetwork )    

        {

        iConnUiUtils->CancelSearchWLANNetwork();

        }

    else if ( iWlanQueryState == EWepSettings )    

        {

        iNotifier.CancelNotifier( KUidEasyWepDlg );

        }

    else if( iWlanQueryState == EWPS )

        {

        iWps->CancelWiFiProt();

        }

    else if ( iWlanQueryState == EWpaSettings )

        {

        iNotifier.CancelNotifier( KUidEasyWpaDlg );

        }

    else // ERetrySettingsStorage

        {

        iTimer.Cancel();

        }

    }

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

// CMPMWlanQueryDialog::RunL

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

//

void CMPMWlanQueryDialog::RunL()

    {

    MPMLOGSTRING3( "CMPMWlanQueryDialog::RunL status %d state %d", 

                   iStatus.Int(), 

                   iWlanQueryState )

    if( iWlanQueryState == EOffline )

        {

        if( iStatus.Int() == KErrNone )

            {

            iIapSelection.SetOfflineNoteResponse( EOfflineResponseYes );

            if( iIapSelection.Session()->MyServer().CommsDatAccess()->CheckEasyWLanL( iWlanIapId ) )

                {

                MPMLOGSTRING( "CMPMWlanQueryDialog::RunL starting wlan network query" )

                GetNetworkPrefs();

                return;

                }

            }

        else if ( iStatus.Int() == KErrCancel )

            {

            iIapSelection.SetOfflineNoteResponse( EOfflineResponseNo );

            MPMLOGSTRING2( "CMPMWlanQueryDialog::RunL offline query returned %d", 

                           iStatus.Int() )

            }

        else

            {

            MPMLOGSTRING2( "CMPMWlanQueryDialog::RunL offline query returned %d", 

                           iStatus.Int() )

            }

        }

    else if( iWlanQueryState == EWlanNetwork )

        {

        if( iStatus.Int() == KErrNone )

            {

            TUint secMode( 0 );

            TWlanNetMode connMode( EInfra );

            TInt err = ConnSecModeToCommsDatSecMode( iNetworkPrefs().iSecMode,

                                                     secMode );

            if( err != KErrNone )

       	    	{

       	    	MPMLOGSTRING( "CMPMWlanQueryDialog::RunL, Unknown security mode" )

       	    	iWlanIapId = 0;

                iWlanQueryState = EWlanNetwork;

       	    	iIapSelection.UserWlanSelectionDoneL( KErrCouldNotConnect, iWlanIapId );

       	    	return;

       	    	}

            TUint32 configuredIap = iIapSelection.Session()->MyServer().

                CommsDatAccess()->CheckWLANIapWithSsidL( iNetworkPrefs().iSsId, 

                                                         secMode,

                                                         connMode );

            // If previously unknown IAP, query wep/wpa parameters

            //

            if( !configuredIap )

                {

                iEasyWlanSelected = ETrue;

                if ( iNetworkPrefs().iProtectedSetupSupported && 

                     iNetworkPrefs().iNetworkMode != EWlanConnectionModeAdhoc )

                    {

                    StartWpsDlgL();

                    return;                                    

                    }         

                // WEP

                //

                if( iNetworkPrefs().iSecMode == EWlanConnectionSecurityWep )

                    {

                    MPMLOGSTRING( "CMPMWlanQueryDialog::RunL unknown wep network" )

                    iWlanQueryState = EWepSettings;

                    iNotifier.StartNotifierAndGetResponse( iStatus, 

                                                           KUidEasyWepDlg, 

                                                           iNotifWep, 

                                                           iNotifWep );

                    SetActive();

                    return;

                    }

                // WPA

                //

                else if ( iNetworkPrefs().iSecMode == EWlanConnectionSecurityWpaPsk )

                    {

                    MPMLOGSTRING( "CMPMWlanQueryDialog::RunL unknown wpa network" )

                    iWlanQueryState = EWpaSettings;

                    iNotifier.StartNotifierAndGetResponse( iStatus, 

                                                           KUidEasyWpaDlg, 

                                                           iNotifWpaKey, 

                                                           iNotifWpaKey );

                    SetActive();

                    return;

                    }

                else

                    {

                    MPMLOGSTRING2( "CMPMWlanQueryDialog::RunL security mode %d", 

                                   iNetworkPrefs().iSecMode )

                    }

                }

        	else

        	    {

        	    iWlanIapId = configuredIap;

        	    MPMLOGSTRING2( "CMPMWlanQueryDialog::RunL found configured iap matching ssid, id %d", 

        	                   iWlanIapId )

        	    }

            }

        else if( iStatus.Int() == KErrCancel )

            {

            iEasyWlanSelected = EFalse;

            MPMLOGSTRING( "CMPMWlanQueryDialog::RunL easy wlan dialog cancelled, \

setting easy wlan as not selected" )

            }

        else

            {

            MPMLOGSTRING2( "CMPMWlanQueryDialog::RunL EWlanNetwork error %d", 

                iStatus.Int() )

            }

        }

    else if( iWlanQueryState == EWepSettings || iWlanQueryState == EWpaSettings )

        {

        if( iStatus.Int() == KErrCancel )

      	   {

            MPMLOGSTRING( "CMPMWlanQueryDialog::Key dialog cancelled,back to easy wlan" )

            iNetworkPrefs().iSsId.FillZ();

            iNetworkPrefs().iNetworkMode = EWlanConnectionModeNotConnected;

            iNetworkPrefs().iSecMode = EWlanConnectionSecurityOpen;

            GetNetworkPrefs();

            return;

            }

        }

    else if( iWlanQueryState == EWPS )

        {

        MPMLOGSTRING2( "CMPMWlanQueryDialog::RunL WPS, status %d", iStatus.Int() )

        if( iStatus.Int()  == KErrNone )

            {

            if( iWpsReturn == WiFiProt::EWiFiOK)

                {

                MPMLOGSTRING( "CMPMWlanQueryDialog::RunL WPS ok" )

                iWpsCompleted = ETrue;

                }

            else if ( iWpsReturn == WiFiProt::EWiFiCancel )

                {

                MPMLOGSTRING( "CMPMWlanQueryDialog::RunL WPS cancelled" )

                iStatus = KErrCancel;

                }

            else // WiFiProt::EWiFiNoAuto

                {

                MPMLOGSTRING( "CMPMWlanQueryDialog::RunL No Auto, starting WPA key query" )

                iWlanQueryState = EWpaSettings;

                iNotifier.StartNotifierAndGetResponse( iStatus, 

                                                       KUidEasyWpaDlg, 

                                                       iNotifWpaKey, 

                                                       iNotifWpaKey );

                SetActive();

                return;

                }

            }

        }

    else if ( iWlanQueryState == ERetrySettingsStorage )

        {

        // Retry settings storage

        MPMLOGSTRING( "CMPMWlanQueryDialog::RunL Retry settings storage" )

        }

    else

        {

		MPMLOGSTRING2( "CMPMWlanQueryDialog::RunL, unknown state: %d", iWlanQueryState )

        User::Leave( KErrCancel );

        }

    TRAPD( leaveCode, iIapSelection.UserWlanSelectionDoneL( iStatus.Int(), iWlanIapId ) );

    if( leaveCode != KErrNone )

        {

        // Something caused method to leave, if CommsDat was locked we should retry 

        if ( iStatus.Int() == KErrNone &&

             leaveCode == KErrLocked &&

             iRetryCount > 0 )

            {

            MPMLOGSTRING2( "CMPMWlanQueryDialog::RunL Start retry timer, retry count %d", iRetryCount )

            iWlanQueryState = ERetrySettingsStorage;

            iRetryCount--;

            iTimer.After( iStatus, KStoreRetryDelay );

            SetActive();

            return;

            }

        else

            {

            User::Leave( leaveCode );

            }

        }

    iWlanIapId = 0;

    iWlanQueryState = EWlanNetwork;

    }

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

// CMPMWlanQueryDialog::RunError

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

//

TInt CMPMWlanQueryDialog::RunError( TInt aError )

    {

    MPMLOGSTRING2( "CMPMWlanQueryDialog::RunError failed with %d", aError )

    iEasyWlanSelected = EFalse;    

    iIapSelection.ChooseIapComplete( aError, NULL );    

    return KErrNone;

    }

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

// CMPMWlanQueryDialog::StartWlanQueryL

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

//

void CMPMWlanQueryDialog::StartWlanQueryL()

    {

    MPMLOGSTRING( "CMPMWlanQueryDialog::StartWlanQuery" )

    iRetryCount = KStoreRetryCount;

    // if first dialog user, add it to the array and continue.

    //

    if ( iIapSelection.Session()->MyServer().WlanQueryQueue()->Count() == 0 )

        {

        MPMLOGSTRING( "CMPMWlanQueryDialog::StartWlanQuery First one, start immediately" )

        iIapSelection.Session()->MyServer().AppendWlanQueryQueueL( this );

        }

    // if another dialog should be processed before this, just add and return.

    //

    else if ( iIapSelection.Session()->MyServer().FirstInWlanQueryQueue() != this )

        {

        MPMLOGSTRING( "CMPMWlanQueryDialog::StartWlanQuery Latter, process later" )

        iIapSelection.Session()->MyServer().AppendWlanQueryQueueL( this );

        return;

        }

    // else Continue to process the first dialog.(this one)

    // FirstInWlanQueryQueue() == this && Count() > 0

    TUint32 activeWlanIap = iIapSelection.Session()->MyServer().IsWlanConnectionStartedL( 

        iIapSelection.Session()->MyServer().CommsDatAccess() );

    // Get EmergencyCallInfo via Publish & Subscribe

    // 

    TInt emergencyCallEstablished( 0 );

    RProperty::Get( KPSUidCtsyEmergencyCallInfo, 

                    KCTSYEmergencyCallInfo, 

                    emergencyCallEstablished );  

    MPMLOGSTRING2( "CMPMWlanQueryDialog::StartWlanQuery KCTSYEmergencyCallInfo = %d", 

                   emergencyCallEstablished )

    if( !emergencyCallEstablished && 

        iIapSelection.Session()->IsPhoneOfflineL() && 

        !activeWlanIap && 

        iIapSelection.OfflineNoteResponse() != EOfflineResponseYes &&

        iOverrideStatus == KErrNone )

        {

        // if user has already refused offline note complete immediately

        //

        if ( iIapSelection.OfflineNoteResponse() == EOfflineResponseNo )

            {

            MPMLOGSTRING( "CMPMWlanQueryDialog::StartWlanQuery user has already refused offline" )

            iIapSelection.UserWlanSelectionDoneL( KErrCancel, iWlanIapId );

            }

        else

            {

            MPMLOGSTRING( "CMPMWlanQueryDialog::StartWlanQuery, starting offline note" )            

            iWlanQueryState = EOffline;

            iNotifier.StartNotifierAndGetResponse( iStatus, 

                                                   KUidCOfflineWlanNoteDlg, 

                                                   KNullDesC8(), 

                                                   iOfflineReply );

            SetActive();

            }

        }

    // if easy wlan iap and some wlan iap started, use existing connection

    //

    else if( iIapSelection.Session()->MyServer().CommsDatAccess()->CheckEasyWLanL( iWlanIapId )  && 

             activeWlanIap )

        {

        MPMLOGSTRING2( "CMPMWlanQueryDialog::StartWlanQuery using active WLAN IAP %d", 

                      activeWlanIap )

        iIapSelection.UserWlanSelectionDoneL( KErrNone, activeWlanIap );      

        }

    // if easy wlan iap and easy wlan is not already started

    // 

    else if( iIapSelection.Session()->MyServer().CommsDatAccess()->CheckEasyWLanL( iWlanIapId )  && 

             !iIapSelection.Session()->MyServer().CheckIfStarted( iWlanIapId ) &&

             iNetworkPrefs().iSsId.Length() == 0 &&

             iOverrideStatus == KErrNone )

        {

        MPMLOGSTRING( "CMPMWlanQueryDialog::StartWlanQuery starting network query" )

        GetNetworkPrefs();

        }

    // if an error was given through OfferInformation() -call we abort the execution.

    //

    else if ( iOverrideStatus != KErrNone )

        {

        MPMLOGSTRING2( "CMPMWlanQueryDialog::StartWlanQuery inherited error %d", iOverrideStatus )

        iIapSelection.UserWlanSelectionDoneL( iOverrideStatus, iWlanIapId );

        }

    else

        {

        MPMLOGSTRING( "CMPMWlanQueryDialog::StartWlanQuery no wlan dialog to show" )

        iIapSelection.UserWlanSelectionDoneL( KErrNone, iWlanIapId );

        }

    }

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

// CMPMWlanQueryDialog::OfferInformation

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

//

void CMPMWlanQueryDialog::OfferInformation(

                TUint32 aWlanIapId, 

                TOfflineNoteResponse aOfflineStatus,

                TInt aDialogStatus )

    {

    TBool isEasyWlan( EFalse );

    // Take information from earlier note into use

    // if the selected IAP is EasyWLAN or Offline note response was No.

    //

    TRAP_IGNORE( isEasyWlan = 

        iIapSelection.Session()->MyServer().CommsDatAccess()->CheckEasyWLanL( iWlanIapId ); )

    if ( isEasyWlan ) 

        {

        // iEasyWlanSelected is not passed as only the first connection 

        // should write the easy wlan settings to commsdat if easy wlan is used.

        // 

        MPMLOGSTRING3( "CMPMWlanQueryDialog<0x%x>::OfferInformation: EasyWLAN, iap %d", 

                       iIapSelection.Session()->ConnectionId(),

                       aWlanIapId ) 

        iWlanIapId      = aWlanIapId;

        iOverrideStatus = aDialogStatus;