/*

* Copyright (c) 2007-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:  Implementation of TWsfMainController.

*

*/

//  EXTERNAL INCLUDES

#include <e32def.h>

#include <wlansniffer.rsg>

#include <utf.h>

#include <apgcli.h>

#include <AknQueryDialog.h>

#include <StringLoader.h>

#include <cmmanagerext.h>

//  CLASS HEADER

#include "wsfmaincontroller.h"

//  INTERNAL INCLUDES

#include "wsfmodel.h"

#include "wsfwlaninfo.h"

#include "wsfwlaninfoarray.h"

#include "wsfappui.h"

#include "wsfmainviewcontrollerif.h"

#include "wsfdetailsviewcontrollerif.h"

#include "wsfmainapplication.hrh"

#include "wsfwlaninfoarrayvisitor.h"

#include "wsflogger.h"

//  LOCAL DEFINITIONS

#ifdef _DEBUG

    _LIT( KMainControllerPanic, "TWsfMainController" );

    #define _ASSERTD( cond ) __ASSERT_DEBUG( (cond), \

            User::Panic( KMainControllerPanic, __LINE__) )

#else

    #define _ASSERTD( cond ) {}

#endif //_DEBUG

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

// TWsfMainController::Initialize

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

//

void TWsfMainController::Initialize( 

                            CWsfAppUi& aAppUi, 

                            CWsfModel& aModel, 

                            CWsfWlanInfoArrayVisitor &aWlanInfoBranding )

    {

    iAppUi = &aAppUi;

    iModel = &aModel;

    iWlanInfoBranding = &aWlanInfoBranding;

    iModel->SetConnecting( EFalse );

    }

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

// TWsfMainController::UpdateViewL

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

//

void TWsfMainController::UpdateViewL()

    {

    LOG_ENTERFN( "TWsfMainController::UpdateViewL" ); 

    CWsfWlanInfoArray* array = iModel->GetWlanListL();

    array->SortArrayL( *iWlanInfoBranding );

    LOG_WRITEF( "ActiveViewL: %x", iModel->ActiveViewL().iUid );

    switch ( iModel->ActiveViewL().iUid )

        {

        case EMainViewId:

            {  

            _ASSERTD( iMainView );          

            iMainView->UpdateWlanListL( array );  

            break;

            }

        case EDetailsViewId:

            {

            _ASSERTD( iDetailsView );

            iMainView->UpdateWlanListInBackgroundL( array );

            iDetailsView->WlanListChangedL( array );

            break;           

            }

        case EConnectedDetailsViewId:

            {

            iMainView->UpdateWlanListL( array );  

            iAppUi->UpdateConnectedDetailsL( array );

            break;           

            }

        default:

            {

            // Invalid view ID, make panic.

            _ASSERTD( 0 );   

            break;    

            }

        }

    }

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

// TWsfMainController::UpdateViewL

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

//

void TWsfMainController::UpdateViewL( CWsfWlanInfoArray* aInfoArray )

    {

    LOG_ENTERFN( "TWsfMainController::UpdateViewL( aInfoArray ) " );

    LOG_WRITEF( "ActiveViewL: %x", iModel->ActiveViewL().iUid );    

    switch ( iModel->ActiveViewL().iUid )

        {

        case EMainViewId:

            {            

            iMainView->UpdateWlanListL( aInfoArray );  

            break;

            }

        case EDetailsViewId:

            {

            iDetailsView->WlanListChangedL( aInfoArray );

            break;           

            }

        case EConnectedDetailsViewId:

            {

            iMainView->UpdateWlanListL( aInfoArray );  

            iAppUi->UpdateConnectedDetailsL( aInfoArray );

            break;           

            }

        default:

            {

            // Invalid view ID, make panic.

            _ASSERTD( 0 );   

            break;    

            }

        }    

    }

// Events from AppUi

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

// TWsfMainController::ShowWlanListL

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

//

void TWsfMainController::ShowWlanListL()

    {

    LOG_ENTERFN( "TWsfMainController::ShowWlanListL" ); 

    _ASSERTD( iAppUi );    

    _ASSERTD( iModel );

    iModel->SetActiveViewL( EMainViewId );

    iAppUi->ActivateMainViewL();

    }

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

// TWsfMainController::ShowDetailsL

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

//

void TWsfMainController::ShowDetailsL()

   {

   LOG_ENTERFN( "TWsfMainController::ShowDetailsL" ); 

    _ASSERTD( iAppUi );    

    _ASSERTD( iModel );

    _ASSERTD( iModel->ActiveViewL().iUid != EDetailsViewId );

    TWsfWlanInfo* selectedWlan = iMainView->SelectedItem();

    if ( selectedWlan ) 

        {

        TBool connected = selectedWlan->Connected();

        if( connected ) // Connected Details View - Replaced with dialog

            {

            // Work around - Emulated view

            iModel->SetActiveViewL( EConnectedDetailsViewId );

            // Holds selected wlan Ssid

            HBufC8* ssid = selectedWlan->GetSsidAsUtf8LC(); 

            // Holds current wlan array 

            if ( !iInfoArray )

                {

                iInfoArray = iModel->GetWlanListL();

                iInfoArray->SortArrayL( *iWlanInfoBranding );

                }

            // Start and execute the Connected Details dialog

            // Set array and Ssid to detail view

            iAppUi->StartConnectedDetailsL( iInfoArray, *ssid );

            CleanupStack::PopAndDestroy( ssid ); 

            // After the dismissal of the Connected Details dialog, 

            // change back to the main view 

            ShowWlanListL();

            }

        else

            {

            iDetailsView = &( iAppUi->DetailsView( EDetailsViewId ) ); 

              iModel->SetActiveViewL( EDetailsViewId );

            iDetailsView->SetPartner( *this );

            // Holds selected wlan Ssid

            HBufC8* ssid = selectedWlan->GetSsidAsUtf8LC(); 

            // Holds current wlan array 

            if ( !iInfoArray )

                {

                iInfoArray = iModel->GetWlanListL();

                iInfoArray->SortArrayL( *iWlanInfoBranding );

                }

            //Set array and Ssid to detail view

            iDetailsView->SetWlanListL( iInfoArray, *ssid );

            CleanupStack::PopAndDestroy( ssid );        

            iAppUi->ActivateDetailsViewL( iModel->ActiveViewL() );

            }

        }

    }

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

// TWsfMainController::MainViewCreatedL

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

//

void TWsfMainController::MainViewCreatedL()

    {

    LOG_ENTERFN( "TWsfMainController::MainViewCreatedL" );

    iMainView = &( iAppUi->MainView() ); 

    iMainView->SetPartner( *this );

    iModel->SetActiveViewL( EMainViewId );

    if ( !iModel->Refreshing() )

            { 

            iModel->SetRefreshState( ETrue );               

            }

     }

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

// TWsfMainController::WlanListChangedL

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

//  

void TWsfMainController::WlanListChangedL()

    {

    LOG_ENTERFN( "TWsfMainController::WlanListChangedL" ); 

    if ( iModel->IsConnecting() )

        {

        LOG_WRITE( "We are connecting just return from here" );

        return;

        }

    if ( iModel->Refreshing() )

        {

        // Make sure if leave occures that we don't block ourselves for retry

        CleanupStack::PushL( TCleanupItem( RestoreRefreshState, this ) );

        iModel->SetRefreshState( EFalse );

        if ( iAppUi )

            {            

            iAppUi->HideWaitNoteL();

            iInfoArray = iModel->GetWlanListL();

            if ( !iInfoArray->Count() )

                {        

                iAppUi->ShowNoWlansFoundInfoL();       

                }

            UpdateViewL();        

            }

        // pop cleanup item RestoreRefreshState

        CleanupStack::Pop();

        }

    }

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

// TWsfMainController::NotifyEngineError

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

//  

void TWsfMainController::NotifyEngineError( TInt aError )

    {

    LOG_ENTERFN( "TWsfMainController::NotifyEngineError" );

    switch ( aError )

        {

        case KErrServerTerminated:

            {

            break;

            }

        default:

            {

            TRAP_IGNORE( iAppUi->ShowGlobalErrorNoteL( aError ) );

            }

        }

    }

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

// TWsfMainController::ScanDisabledL

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

//          

void TWsfMainController::ScanDisabledL()

    {

    // no implementation required

    }

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

// TWsfMainController::ScanEnabledL

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

//  

void TWsfMainController::ScanEnabledL()

    {

    // no implementation required

    }

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

// TWsfMainController::WlanConnectionActivatedL

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

// 

void TWsfMainController::WlanConnectionActivatedL()

    {

    LOG_ENTERFN( "TWsfMainController::WlanConnectionActivatedL" ); 

    // update the model and refresh ui

    if ( iInfoArray )

        {

        TBool found = EFalse; 

        TWsfWlanInfo info;

        iModel->GetConnectedWlanDetailsL( info );

        if ( info.iIapId )

            {

            // find the entry for iapid

            // mark it connected - sort the array and refresh

            TWsfWlanInfo* temp = iInfoArray->Match( info.iIapId, 

                                                    iInfoArray->Count() );

            if ( temp )

               {

               found = ETrue;

               temp->iConnectionState = EConnected;

               iInfoArray->SortArrayL();

               UpdateViewL( iInfoArray );

               }

            }

        if ( !found )

            {

            // find the entry 

            // mark it connected - sort the array and refresh

            TWsfWlanInfo* temp = iInfoArray->Match( info.iSsid, 

                                                    iInfoArray->Count() );

            if ( temp )

                {

                temp->iConnectionState = EConnected;

                temp->iIapId = info.iIapId;

                iInfoArray->SortArrayL();

                UpdateViewL( iInfoArray );

                }

            }

        }

    }

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

// TWsfMainController::WlanConnectionClosedL

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

//         

void TWsfMainController::WlanConnectionClosedL()

    {

    LOG_ENTERFN( "TWsfMainController::WlanConnectionClosedL" ); 

    // update the model and refresh ui

    if ( iInfoArray )

        {

        // check if the array has any items

        if ( iInfoArray->Count() )

            {

            TWsfWlanInfo* firstItem = iInfoArray->At( 0 );

            if ( firstItem && ( firstItem->Connected() ||

                                firstItem->iConnectionState == EConnecting ) )

                {

                LOG_WRITEF( "info state = %d", firstItem->iConnectionState );

                firstItem->iConnectionState = ENotConnected;

                TRAPD( error, iModel->CheckIsIapIdValidL( firstItem->iIapId ) );

                if ( error )

                    {

                    LOG_WRITEF( "Iap Id is not valid - error=%d", error );

                    if ( firstItem->iRawSsid.Length() )

                        {

                        firstItem->iSsid.Copy( firstItem->iRawSsid );

                        }

                    firstItem->iIapId = 0;

                    }

                iInfoArray->SortArrayL();

                UpdateViewL( iInfoArray );                    

                }

            }

        }

    // Abort current scan if exists so that we get 

    // newest scan results propagated to ui

    iModel->AbortScanningL();

    iModel->RefreshScanL();     

    }

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

// TWsfMainController::ConnectingFinishedL

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

//

void TWsfMainController::ConnectionCreationProcessFinishedL( TInt /*aResult*/ )

    {

    // no implementation required

    }

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

// TWsfMainController::ShowMenuBarL

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

//

void TWsfMainController::ShowMenuBarL()

    {

    LOG_ENTERFN( "TWsfMainController::ShowMenuBarL" ); 

    iAppUi->ShowMenuBarL();

    }

// --------------------------- Events from the details view ------------------

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

// TWsfMainController::CloseDetailsViewL

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

//    

void TWsfMainController::CloseDetailsViewL()

    {

    LOG_ENTERFN( "TWsfMainController::CloseDetailsViewL" ); 

    ShowWlanListL();

    // After the Details View closed the mainview's 

    // WlanList will be refreshed.

    iModel->RefreshScanL();

    }

// ------------------------------- Menu press handler ------------------------

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

// TWsfMainController::StartBrowsingL

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

//

void TWsfMainController::StartBrowsingL()

    {

    LOG_ENTERFN( "TWsfMainController::StartBrowsingL" ); 

    if ( iAppUi->SuppressingKeyEvents() || iModel->IsConnectedL() && 

             ( !iMainView->SelectedItem() || 

               !iMainView->SelectedItem()->Connected() ) )

        {

        iAppUi->ShowErrorNoteL( R_QTN_WLAN_INFO_CONNECTION_ALREADY_ACTIVE );

        return;

        }

    // make sure we don't suppress our key events forever

    CleanupStack::PushL( TCleanupItem( ReleaseSuppressingKeyEvents, this ) );

    iAppUi->SetSuppressingKeyEvents( ETrue );

    TWsfWlanInfo* selectedItem = iMainView->SelectedItem();

    TWsfWlanInfo info;

    if ( selectedItem )

        {

        info = *selectedItem;

        }

    // Prevent connections to ad-hoc + WPA 

    if ( info.iNetMode == CMManager::EAdhoc 

            && info.iSecurityMode == CMManager::EWlanSecModeWpa )

        {

        iAppUi->ShowGlobalErrorNoteL( KErrNotSupported );

        CleanupStack::PopAndDestroy();

        return;

        }

    TInt result( KErrNone );

    TWsfIapPersistence persistence = EIapPersistent;

    if ( !info.Known() && !info.Connected() )

        {

        // if not known yet, create an IAP

        if ( iModel->CreateAccessPointL( info, EFalse ) )

            {

            persistence = EIapExpireOnDisconnect;

            // update iapID to list

            UpdateIapIdToInfoArrayL( info );

            }

        else

            {

            result = KErrGeneral;

            }

        }

    if ( info.iIapId && !info.Connected() )

        {

        // hopefully we have a valid IAP id inside

        result = iModel->ConnectL( info.iIapId, EFalse, persistence );

        }

    else if ( !info.Connected() )

        {

        result = KErrGeneral;

        }

    // pop cleanup item ReleaseSuppressingKeyEvents

    CleanupStack::Pop();

    iAppUi->SetSuppressingKeyEvents( EFalse );

    if ( !result )

        {

        TUint32 passedIap( info.iIapId );

        if ( info.Connected() && !passedIap )

            {

            // in case we have an EasyWLAN here

            RCmManagerExt cmmanager;

            cmmanager.OpenLC();

            passedIap = cmmanager.EasyWlanIdL();

            CleanupStack::PopAndDestroy( &cmmanager );

            }

        // launch the browser

        iModel->LaunchBrowserL( passedIap );

        }

    else if ( result == KErrCancel )

        {

        // connection creation was cancelled, refresh the view