/*

* 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 CWsfAiPlugin

*

*/

//  EXTERNAL INCLUDES

#include <aicontentobserver.h>

#include <aiutility.h>

#include <apgcli.h>

#include <wsfaipluginrsc.rsg>

#include <e32std.h>

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <f32file.h>

#include <AknsConstants.h>

#include <AknUtils.h>

#include <StringLoader.h>

#include <bautils.h>

#include <avkon.rsg>

#include <apgtask.h>

#include <eiklabel.h>

#include <data_caging_path_literals.hrh> // KDC_APP_BITMAP_DIR

//  INTERNAL INCLUDES

#include "wsfaiplugin.h"

#include "wsfaipluginuids.hrh"

#include "wsfaiplugincontentmodel.h"

#include "wsfaimodel.h"

#include "wsfmodel.h"

#include "wsfaiview.h"

#include "wsficonarraycreator.h"

#include "wsfdbobserver.h"

#include "wsflogger.h"

// define icon id for Navigation Bar icon

LOCAL_D const TInt KNaviBarIcon = EWlanOffIcon;

LOCAL_D const TInt KTransparentIcon = ETransparentIcon;

LOCAL_D const TUid KUidSnifferApp = {0x10281CAA};

LOCAL_D const TInt KRefreshStepTime = 200 * 1000;

LOCAL_D const TInt KConnectingStepTime = 200 * 1000;

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

// CWsfAiPlugin::NewL

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

//

CWsfAiPlugin* CWsfAiPlugin::NewL()

    {

    LOG_ENTERFN( "CWsfAiPlugin::NewL" );

    CWsfAiPlugin* self = new (ELeave) CWsfAiPlugin;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CWsfAiPlugin::~CWsfAiPlugin

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

//

CWsfAiPlugin::~CWsfAiPlugin()

    {

    // Cancel periodic animation update

    if ( iAnimationPeriodic )

        {

        LOG_WRITE( "Cancel animation update" );

        iAnimationPeriodic->Cancel();

        delete iAnimationPeriodic;

        iAnimationPeriodic = NULL;

        }

    delete iDbObserver;

    delete iModel;

    delete iAiModel;

    delete iUi;

    delete iCurrentSignalStrength;

    delete iCurrentSecureInfo;

    if ( iWlanTitle )

        {

        delete iWlanTitle;

        }

    if ( iMskActivate )

        {

        delete iMskActivate;

        }

    if ( iConnectedTo )

        {

        delete iConnectedTo;

        }

    if ( iKnownNetworkFound )

        {

        delete iKnownNetworkFound;

        }

    CCoeEnv::Static()->DeleteResourceFile( iResourceFileOffset );

    iObservers.Close();

    Release( iContent );

    Release( iEvents );

    }

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

// CWsfAiPlugin::CWsfAiPlugin

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

//

CWsfAiPlugin::CWsfAiPlugin()

    {

    }

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

// CWsfAiPlugin::ConstructL

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

//

void CWsfAiPlugin::ConstructL()

    {

    LOG_ENTERFN( "CWsfAiPlugin::ConstructL" );

    AllocateResourcesL();

    iContent = AiUtility::CreateContentItemArrayIteratorL( 

                                                    KAiWizardContent );

    iEvents = AiUtility::CreateContentItemArrayIteratorL( KAiWizardEvents );

    // create the engine first...

    iModel = CWsfModel::NewL( iController, EFalse );

    // then model

    iAiModel = CWsfAiModel::NewL();

    iUi = CWsfAiView::NewL( *this );

    iDbObserver = CWsfDbObserver::NewL();

    iController.SetUi( *static_cast<CWsfAiView*>( iUi ) );

    }

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

// CWsfAiPlugin::PublishContentL

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

//

void CWsfAiPlugin::PublishContentL( CArrayFix<TInt>* aPublishIconArray, 

                                    CEikLabel* aText1 )

    {

    LOG_ENTERFN( "CWsfAiPlugin::PublishContentL" );

    TInt leftBoundary( 0 );

    TInt rightBoundary( 0 );

    TChar boundary('\'');

    HBufC* localCurrentStatusText( NULL );

    HBufC* localCurrentTypeText( NULL );

    HBufC* localCurrentNetworkStatus( NULL );

    HBufC* localCurrentNetworkName( NULL );

    HBufC* localFullText = ( aText1->Text() )->AllocLC();

    // Locate ' chars from the full string

    TPtrC fullText = localFullText->Des();

    leftBoundary = fullText.Locate( boundary );    // char = '

    rightBoundary = fullText.LocateReverse( boundary );

    // if we have status name then we parse it

    if ( leftBoundary != rightBoundary && 

         leftBoundary != KErrNotFound && 

         rightBoundary != KErrNotFound )

        {

        TPtrC begin = fullText.Mid( leftBoundary, 

                                    rightBoundary - leftBoundary + 1 );

        localCurrentStatusText = begin.AllocLC();

        localCurrentNetworkName = begin.AllocLC();

        TPtrC end = fullText.Mid( rightBoundary + 1 );

        localCurrentTypeText = end.AllocLC();

       }

    else

        {

        localCurrentStatusText = fullText.AllocLC();

        delete localCurrentTypeText;

        localCurrentTypeText = NULL;

        }

    //Connected

    if ( localCurrentNetworkName )

        {

        if ( iAiModel->Connected() )

            {

            if ( !iConnectedTo )

                {

                iConnectedTo = StringLoader::LoadL( 

                        R_QTN_SNIFFER_PLUG_IN_CONNECTED_TO );

                }

            localCurrentNetworkStatus = iConnectedTo;

            }

        else

            {

            if ( !iKnownNetworkFound )

                {

                iKnownNetworkFound = StringLoader::LoadL( 

                        R_QTN_SNIFFER_PLUG_IN_WLAN_NETWORK_FOUND );

                }

            localCurrentNetworkStatus = iKnownNetworkFound;

            }

        }

    else

        {

        localCurrentNetworkStatus = localCurrentStatusText;

        }

    TBool published( EFalse );

    TInt iconId( 0 );

    ClearL();   // Clear all WLAN Wizard content from the AI2

    for ( iCurrentObserverIndex = 0; 

          iCurrentObserverIndex < iObservers.Count(); 

          ++iCurrentObserverIndex )

        {

        MAiContentObserver* observer = iObservers[iCurrentObserverIndex];

        observer->StartTransaction( reinterpret_cast<TInt32>( this ) );

        // make sure we cancel the tracsaction if leaves

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

        // Publish Full Text if Classic or Navigation Bar Classic used

        if ( localFullText )

            {

            published = PublishText( observer, 

                                     EAiWizardContentFullText,

                                     *localFullText ) || published;

            }

        // Publish Navigation Bar Icon: EAiWizardContentNaviBarIcon

        published = PublishIconL( observer, 

                                  EAiWizardContentNaviBarIcon,

                                  KNaviBarIcon ) || published;

        // Publish Application Title: EAiWizardContentTitleText

        if ( !iWlanTitle )

            {

            iWlanTitle = StringLoader::LoadL( R_QTN_AI_WIZARD_TITLE );

            }

        if ( iWlanTitle )

            {

            published = PublishText( observer, 

                                     EAiWizardContentTitleText,

                                     *iWlanTitle ) || published;

            }

        if ( localCurrentStatusText )

            {

            // Publish Status icon: EAiWizardContentStatusIcon

            iconId = aPublishIconArray->At( 0 );

            published = PublishIconL( observer, 

                                      EAiWizardContentStatusIcon,

                                      iconId ) || published;

            // Publish Status text: EAiWizardContentStatusText

            published = PublishText( observer, 

                                     EAiWizardContentStatusText,

                                     *localCurrentStatusText ) || published;

            }

        if ( localCurrentTypeText )

            {

            // Publish Type icon: EAiWizardContentTypeIcon

            published = PublishIconL( observer, 

                                      EAiWizardContentTypeIcon,

                                      KTransparentIcon ) || published;

            // Publish Type text: EAiWizardContentTypeText

            published = PublishText( observer, 

                                     EAiWizardContentTypeText,

                                     *localCurrentTypeText ) || published;

            }

        // Publish Strength icon: EAiWizardContentStrengthIcon

        iconId = aPublishIconArray->At( 2 );

        published = PublishIconL( observer, 

                                  EAiWizardContentStrengthIcon,

                                  iconId ) || published;

        // Publish Strength text: EAiWizardContentStrengthText

        if ( iCurrentSignalStrength && iScanState )

            {

            published = PublishText( observer, 

                                     EAiWizardContentStrengthText,

                                     *iCurrentSignalStrength ) || published;

            }

        // Publish Secure icon: EAiWizardContentSecureIcon

        iconId = aPublishIconArray->At( 1 );

        published = PublishIconL( observer, 

                                  EAiWizardContentSecureIcon,

                                  iconId ) || published;

        // Publish Secure text: EAiWizardContentSecureText

        if ( iCurrentSecureInfo && iScanState )

            {

            published = PublishText( observer, 

                                     EAiWizardContentSecureText,

                                     *iCurrentSecureInfo ) || published;

            }

        if ( localCurrentNetworkName )

            {

            // Publish NetworkName text: EAiWizardContentNetworkName

            published = PublishText( observer, 

                                     EAiWizardContentNetworkName,

                                     *localCurrentNetworkName ) || published;

            }

        if ( localCurrentNetworkStatus )

            {

            // Publish NetworkName text: EAiWizardContentNetworkName

            published = PublishText( observer, 

                                     EAiWizardContentNetworkStatus,

                                     *localCurrentNetworkStatus ) || published;

            }

        // If we published something then commit, 

        // otherwise cancel transaction

        if ( published )

            {

            observer->Commit( reinterpret_cast<TInt32>( this ) );

            published = EFalse;

            }

        else

            {

            observer->CancelTransaction( reinterpret_cast<TInt32>( this ) );

            }

        CleanupStack::Pop( 1 ); // PublishCleanup()

        }

    if ( localCurrentTypeText ) 

        {

        CleanupStack::PopAndDestroy( localCurrentTypeText );

        }

    if ( localCurrentNetworkName ) 

        {

        CleanupStack::PopAndDestroy( localCurrentNetworkName );

        }

    if ( localCurrentStatusText ) 

        {

        CleanupStack::PopAndDestroy( localCurrentStatusText );

        }

    CleanupStack::PopAndDestroy( localFullText );

    }

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

// CWsfAiPlugin::AllocateResourcesL

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

//

void CWsfAiPlugin::AllocateResourcesL()

    {

    LOG_ENTERFN( "CWsfAiPlugin::AllocateResourcesL" );

    // create resourcefile 

    CCoeEnv* env = CCoeEnv::Static();

    TFindFile finder( env->FsSession() );

    CDir* fileEntries;

    User::LeaveIfError( finder.FindWildByDir( KResourceFile, 

                                              KDC_RESOURCE_FILES_DIR, 

                                              fileEntries ) );

    TParse pathParse;

    pathParse.Set( (*fileEntries)[0].iName, &finder.File(), NULL ); 

    TFileName resourceFile = pathParse.FullName();

    delete fileEntries;

    BaflUtils::NearestLanguageFile( env->FsSession(), resourceFile );

    iResourceFileOffset = env->AddResourceFileL( resourceFile );    

    }

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

// CWsfAiPlugin::Start

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

//

void CWsfAiPlugin::Start( TStartReason /*aReason*/ )

    {

    LOG_ENTERFN( "CWsfAiPlugin::Start");

    }

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

// CWsfAiPlugin::Stop

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

//

void CWsfAiPlugin::Stop( TStopReason /*aReason*/ )

    {

    LOG_ENTERFN( "CWsfAiPlugin::Stop" );

    TRAP_IGNORE( iController.DeInitializeL() );

    if ( iAnimationPeriodic )

        {

        LOG_WRITE( "Cancel animation update" );

        iAnimationPeriodic->Cancel();

        delete iAnimationPeriodic;

        iAnimationPeriodic = NULL;

        }

    }

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

// CWsfAiPlugin::Resume

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

//

void CWsfAiPlugin::Resume( TResumeReason aReason )

    {

    LOG_ENTERFN( "CWsfAiPlugin::Resume" );

    if( aReason == EForeground ) 

        {

        // HS came to foreground -> make refresh scan

        if ( !iAiModel->Connected() && !iModel->IsConnecting() )

            {

            LOG_WRITE( "Call Refresh scan" );

            }

        else

            {

            LOG_WRITE( "Connected no need to refresh scan results" );

            }

        }

    }

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

// CWsfAiPlugin::Suspend

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

//

void CWsfAiPlugin::Suspend( TSuspendReason aReason )

    {

    LOG_ENTERFN( "CWsfAiPlugin::Suspend" );

    if( aReason == EBackground )

        {

        if ( iAnimationPeriodic )

            {

            LOG_WRITE( "Cancel animation update" );

            iAnimationPeriodic->Cancel();

            delete iAnimationPeriodic;

            iAnimationPeriodic = NULL;

            }

        // HS went to background -> dismiss open dialogs/menus

        TRAP_IGNORE( iController.DismissDialogsL() );

        }

    }

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

// CWsfAiPlugin::SubscribeL

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

//

void CWsfAiPlugin::SubscribeL( MAiContentObserver& aObserver )

    {

    LOG_ENTERFN( "CWsfAiPlugin::Subscribe" );

    iObservers.AppendL( &aObserver );

    }

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

// CWsfAiPlugin::ConfigureL

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

//

void CWsfAiPlugin::ConfigureL( RAiSettingsItemArray& /*aSettings*/ )

    {

    LOG_ENTERFN( "CWsfAiPlugin::ConfigureL" );

    }

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

// CWsfAiPlugin::GetPropertyL

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

//

TAny* CWsfAiPlugin::GetProperty( TProperty aProperty )

    {

    if( aProperty == EPublisherContent )

        {

        return iContent;

        }

    else if( aProperty == EPublisherEvents )

        {

        return iEvents;

        }

    return NULL;

    }