/*

* Copyright (c) 2007 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:  WlanPlugin class.

*

*/

// INCLUDE FILES

// User includes

#include "wlanplugin.h"

#include "wlanpluginwlanstate.h"

#include "wlanpluginlogger.h"

// System includes

#include <wlanpluginrsc.rsg>

#include <gsparentplugin.h>

#include <gsfwviewuids.h>

#include <AknNullService.h>

#include <bautils.h>

#include <StringLoader.h>

#include <featmgr.h>

#include <AknGlobalNote.h>

#include <ErrorUI.h>

// Resource file location

_LIT( KWlanPluginResourceFileName, "z:wlanpluginrsc.rsc" );

// ROM folder

_LIT( KDriveZ, "z:" );

// Name of the MBM file containing icons

_LIT( KFileIcons, "wlanplugin.mif");

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

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

// CWlanPlugin::NewL

// First phase constructor

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

CWlanPlugin* CWlanPlugin::NewL( TAny* /*aInitParams*/ )

    {

    CWlanPlugin* self = new ( ELeave ) CWlanPlugin();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;     

    }

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

// Destructor

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

CWlanPlugin::~CWlanPlugin()

    {

    CLOG_ENTERFN( "CWlanPlugin::~CWlanPlugin()" );  

    iResources.Close();

    if( iNullService )

        {

        delete iNullService;

        }

    if ( iWlanState )

        {

        delete iWlanState;

        }

    CLOG_ENTERFN( "CWlanPlugin::~CWlanPlugin()" );    

    }

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

// CWlanPlugin::ConstructL

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

TAny CWlanPlugin::ConstructL()

    {

    CLOG_CREATE;

    CLOG_ENTERFN( "CWlanPlugin::ConstructL()" );

    BaseConstructL(); 

    OpenLocalizedResourceFileL();    

    // Check Wlan support in construction phase to

    // avoid creating of plugin when it is not necessary. 

    if( GetWlanSupported() ) 

        {

        // This is the parent plugin

        CGSParentPlugin* parent = static_cast<CGSParentPlugin*>(

                 AppUi()->View( KGSConPluginUid ) );

        iWlanState = CWlanPluginWlanState::NewL( parent );

        }

    else 

        {

        User::Leave( KErrNotSupported );

        }

    CLOG_LEAVEFN( "CWlanPlugin::ConstructL()" );

    }

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

// CWlanPlugin::Id

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

TUid CWlanPlugin::Id() const

    {

    CLOG_ENTERFN( "CWlanPlugin::Id()" );

    CLOG_LEAVEFN( "CWlanPlugin::Id()" );

    return KWlanPluginUid;

    }

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

// CWlanPlugin::DoActivateL

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

void CWlanPlugin::DoActivateL( const TVwsViewId& /*aPrevViewId*/, 

                                       TUid /*aCustomMessageId*/, 

                                       const TDesC8& /*aCustomMessage*/ )

    {

    CLOG_ENTERFN( "CWlanPlugin::DoActivateL()" );

    //no implementation required

    CLOG_LEAVEFN( "CWlanPlugin::DoActivateL()" );

    }

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

// CWlanPlugin::DoDeactivate

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

void CWlanPlugin::DoDeactivate()

    {

    CLOG_ENTERFN( "CWlanPlugin::DoDeactivate()" );

    //no implementation required

    CLOG_LEAVEFN( "CWlanPlugin::DoDeactivate()" );

    }

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

// CWlanPlugin::GetCaptionL

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

void CWlanPlugin::GetCaptionL( TDes& aCaption ) const

    {

    CLOG_ENTERFN( "CWlanPlugin::GetCaptionL()" );

    StringLoader::Load( aCaption, R_QTN_SET_FOLDER_CONN_WLAN );

    CLOG_LEAVEFN( "CWlanPlugin::GetCaptionL()" );    

    }

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

// CWlanPlugin::HasBitmap

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

TBool CWlanPlugin::HasBitmap() const

    {

    CLOG_ENTERFN( "CWlanPlugin::HasBitmap()" );

    CLOG_LEAVEFN( "CWlanPlugin::HasBitmap()" ); 

    return EFalse;

    }

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

// CWlanPlugin::GetBitmapL

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

void CWlanPlugin::GetBitmapL( CFbsBitmap* /*aBitmap*/, 

                                      CFbsBitmap* /*aMask*/ ) const

    {

    CLOG_ENTERFN( "CWlanPlugin::GetBitmapL()" );

    CLOG_LEAVEFN( "CWlanPlugin::GetBitmapL()" );    

    //no bitmap

    User::Leave( KErrNotFound );

    }

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

// CWlanPlugin::PluginProviderCategory

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

TInt CWlanPlugin::PluginProviderCategory() const

    {

    CLOG_ENTERFN( "CWlanPlugin::PluginProviderCategory()" );

    CLOG_LEAVEFN( "CWlanPlugin::PluginProviderCategory()" ); 

    return EGSPluginProviderOEM;

    }

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

// CWlanPlugin::HandleSelection

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

void CWlanPlugin::HandleSelection(

            const TGSSelectionTypes /*aSelectionType*/ )

    {   

    CLOG_ENTERFN( "CWlanPlugin::HandleSelection()" );    

    TRAPD( error, LaunchSnifferAppL() );

    if( error != KErrNone && 

    	error != KErrNotFound &&

    	error != KErrServerTerminated )

        {

        ShowErrorNote( error );

        }

    CLOG_LEAVEFN( "CWlanPlugin::HandleSelection()" );     

    }

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

// CWlanPlugin::ItemType

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

TGSListboxItemTypes CWlanPlugin::ItemType()

    {

    CLOG_ENTERFN( "CWlanPlugin::ItemType()" );    

    CLOG_LEAVEFN( "CWlanPlugin::ItemType()" );     

    return EGSItemTypeSettingDialog;

    }

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

// CWlanPlugin::CreateIconL

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

CGulIcon* CWlanPlugin::CreateIconL( const TUid aIconType )

    {

    CLOG_ENTERFN( "CWlanPlugin::CreateIconL()" );  

    TFileName iconsFileName;

    iconsFileName.Append( KDriveZ );

    iconsFileName.Append( KDC_APP_BITMAP_DIR );

    iconsFileName.Append( KFileIcons );

    CGulIcon* icon;

    TInt pic, picmask;

    TAknsItemID itemid;

    //if the main icon is asked   

    if ( aIconType == KGSIconTypeLbxItem )

        {

        if ( iWlanState->GetMainIconL( pic, picmask, itemid ) )

            {

            icon = AknsUtils::CreateGulIconL( AknsUtils::SkinInstance(),

                                              itemid, 

                                              iconsFileName, 

                                              pic, 

                                              picmask );

            }

        else

            {

            icon = CGSPluginInterface::CreateIconL( aIconType );

            }

        }

    //if the secondary icon is asked   

    else if ( aIconType == KGSIconTypeDColumn )

        {

        //if there should be icon

        if ( iWlanState->GetStrengthIconL( pic, picmask, itemid ) )

            {

            icon = CGulIcon::NewLC();

            CFbsBitmap* bitmap;

            CFbsBitmap* mask;

            // Creates bitmap an icon. 

            AknsUtils::CreateColorIconL( AknsUtils::SkinInstance(), 

                                         itemid,

                                         KAknsIIDQsnIconColors, 

                                         EAknsCIQsnIconColorsCG13, 

                                         bitmap,

                                         mask, 

                                         iconsFileName, 

                                         pic, 

                                         picmask, 

                                         KRgbBlack );

            icon->SetBitmap( bitmap );

            icon->SetMask( mask );

            CleanupStack::Pop( icon );

            }

        //if there should be no icons

        else

            {

            icon = CGSPluginInterface::CreateIconL( aIconType );

            }

        }

     //in other case of icons

     else

        {

        icon = CGSPluginInterface::CreateIconL( aIconType );

        }

    CLOG_LEAVEFN( "CWlanPlugin::CreateIconL()" );     

    return icon;

    }

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

// CVWlanPlugin::Visible

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

TBool CWlanPlugin::Visible() const

    {

    CLOG_ENTERFN( "CWlanPlugin::Visible()" );    

    CLOG_LEAVEFN( "CWlanPlugin::Visible()" );     

    return GetWlanSupported();

    }

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

// CWlanPlugin::CWlanPlugin

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

CWlanPlugin::CWlanPlugin():

    iResources( *CCoeEnv::Static() ),

    iNullService( NULL )

    {

    // no implementation required

    }

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

// CWlanPlugin::GetValue

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

void CWlanPlugin::GetValue( const TGSPluginValueKeys aKey,

                       TDes& aValue )

    {    

    CLOG_ENTERFN( "CWlanPlugin::GetValue()" );    

    //if the second line of the listbox is asked

    if( aKey == EGSPluginKeySettingsItemValueString )

        {     

        TRAP_IGNORE( iWlanState->GetStateStringL( aValue ) );

        }

    CLOG_LEAVEFN( "CWlanPlugin::GetValue()" );     

    }

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

// CWlanPlugin::OpenLocalizedResourceFileL

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

void CWlanPlugin::OpenLocalizedResourceFileL()

    {

    CLOG_ENTERFN( "CWlanPlugin::OpenLocalizedResourceFileL()" );    

    RFs fsSession;

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

    // Find the resource file:

    TParse parse;

    parse.Set( KWlanPluginResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL );

    TFileName fileName( parse.FullName() );

    // Get language of resource file:

    BaflUtils::NearestLanguageFile( fsSession, fileName );

    // Open resource file:

    iResources.OpenL( fileName );

    // If leave occurs before this, close is called automatically when the

    // thread exits.

    fsSession.Close();

    CLOG_LEAVEFN( "CWlanPlugin::OpenLocalizedResourceFileL()" );     

    }

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

// CWlanPlugin::LaunchSnifferAppL

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

void CWlanPlugin::LaunchSnifferAppL()

    {

    CLOG_ENTERFN( "CWlanPlugin::LaunchSnifferAppL()" );    

    // Launch app

    if ( iNullService )

        {

        delete iNullService;

        iNullService = NULL;

        }         

    iNullService = CAknNullService::NewL( KSnifferAppUid, this );

    CLOG_LEAVEFN( "CWlanPlugin::LaunchSnifferAppL()" );         

    }

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

// CWlanPlugin::GetWlanSupported

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

TBool CWlanPlugin::GetWlanSupported() const

    {

    CLOG_ENTERFN( "CWlanPlugin::GetWlanSupported()" );    

    TBool isWlanSupported = EFalse;

    TRAPD( error, FeatureManager::InitializeLibL() );

    if( !error )

        {

        isWlanSupported = 

            FeatureManager::FeatureSupported( KFeatureIdProtocolWlan );

        FeatureManager::UnInitializeLib();

        }

    CLOG_LEAVEFN( "CWlanPlugin::GetWlanSupported()" );         

    return isWlanSupported;

    }

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

// CWlanPlugin::ShowErrorNote

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

//

void CWlanPlugin::ShowErrorNote(TInt aErrorCode)

    {

    CLOG_ENTERFN( "CWlanPlugin::ShowErrorNote()" );    

    TBool errorNoteShowed = EFalse;

    TRAPD(error, errorNoteShowed = ShowErrorNoteL(aErrorCode));

    if(error || !errorNoteShowed) 

        {

        TRAP_IGNORE( ShowGeneralErrorNoteL() );

        } 

    CLOG_LEAVEFN( "CWlanPlugin::ShowErrorNote()" );           

    }

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

// CWlanPlugin::ShowErrorNoteL

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

//

TBool CWlanPlugin::ShowErrorNoteL(TInt aErrorCode)

    {

    CLOG_ENTERFN( "CWlanPlugin::ShowErrorNoteL()" );    

    CErrorUI* errorUi = CErrorUI::NewLC();

    TBool errorNoteShowed = errorUi->ShowGlobalErrorNoteL( aErrorCode );

    CleanupStack::PopAndDestroy( errorUi );

    CLOG_LEAVEFN( "CWlanPlugin::ShowErrorNoteL()" );           

    return errorNoteShowed;

    }    

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

// CWlanPlugin::ShowGeneralErrorNoteL

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

//

void CWlanPlugin::ShowGeneralErrorNoteL()

    {

    CLOG_ENTERFN( "CWlanPlugin::ShowGeneralErrorNoteL()" );    

    HBufC *msg = StringLoader::LoadLC( R_QTN_ERR_OS_GENERAL );

    CAknGlobalNote *note = CAknGlobalNote::NewLC(); 

    note->ShowNoteL( EAknGlobalErrorNote, *msg );

    CleanupStack::PopAndDestroy( note );

    CleanupStack::PopAndDestroy( msg );

    CLOG_LEAVEFN( "CWlanPlugin::ShowGeneralErrorNoteL()" );           

    }

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

// CWlanPlugin::HandleServerAppExit

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

//

void CWlanPlugin::HandleServerAppExit(TInt aReason)

	{

	CLOG_ENTERFN( "CWlanPlugin::HandleServerAppExit()" );  

	//MAknServerAppExitObserver::HandleServerAppExit( aReason );

	if( aReason == EAknCmdExit )

		{

		iAvkonViewAppUi->Exit();

		}

	CLOG_LEAVEFN( "CWlanPlugin::HandleServerAppExit()" ); 

	}

//End of file