/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  This class implements BgScan AWS communication.

*

*/

/*

* %version: 2 %

*/

#include <e32base.h>

#include <e32atomics.h>

#include "awsinterface.h"

#include "awsenginebase.h"

#include "wlanbgscancommandlistener.h"

#include "wlanbgscancommand.h"

#include "wlanbgscanawscomms.h"

#include "wlanbgscan.h"

#include "am_debug.h"

/**

 * Maximum heap size for AWS thread.

 */

const TInt KMaxHeapSize     = 0x10000;

/**

 * BgScan version communicated to AWS.

 */

const TUint KBgScanVersion  = 1;

/**

 * Index of the first item in an array.

 */

const TInt KFirstItemIndex = 0;

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

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

// CWlanBgScanAwsComms::CWlanBgScanAwsComms

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

//

CWlanBgScanAwsComms::CWlanBgScanAwsComms( CWlanBgScan& aBgScan ) :

    CActive( CActive::EPriorityStandard ),

    iBgScan( aBgScan ),

    iAws( NULL ),

    iAwsImplInfo( NULL ),

    iCommandHandler( NULL ),

    iAwsVersion( 0 ),

    iPendingCommand( EAwsCommandMax ),

    iAwsOk( EFalse )

    {

    DEBUG( "CWlanBgScanAwsComms::CWlanBgScanAwsComms()" );

    }

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

// CWlanBgScanAwsComms::ConstructL

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

//

void CWlanBgScanAwsComms::ConstructL()

    {

    DEBUG( "CWlanBgScanAwsComms::ConstructL()" );

    // create handler for incoming messages from AWS

    iCommandHandler = CWlanBgScanCommand::NewL( *this );

    CActiveScheduler::Add( this );

    // leaves if no AWS present in system

    StartAwsThreadL();

    DEBUG( "CWlanBgScanAwsComms::ConstructL() - done" );    

    }

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

// CWlanBgScanAwsComms::NewL

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

//

CWlanBgScanAwsComms* CWlanBgScanAwsComms::NewL( CWlanBgScan& aBgScan )

    {

    DEBUG( "CWlanBgScanAwsComms::NewL()" );

    CWlanBgScanAwsComms* self = new ( ELeave ) CWlanBgScanAwsComms( aBgScan );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

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

// CWlanBgScanAwsComms::~CWlanBgScanAwsComms()

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

//

CWlanBgScanAwsComms::~CWlanBgScanAwsComms()

    {

    DEBUG( "CWlanBgScanAwsComms::~CWlanBgScanAwsComms()" );

    delete iAws;

    iAws = NULL;

    delete iAwsImplInfo;

    iAwsImplInfo = NULL;

    delete iCommandHandler;

    iCommandHandler = NULL;

    iAwsMsgQueue.Close();

    Cancel();    

    }

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

// CWlanBgScanAwsComms::CleanupEComArray

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

//

void CWlanBgScanAwsComms::CleanupEComArray(TAny* aArray)

    {

    DEBUG( "CWlanBgScanAwsComms::CleanupEComArray()" );

    ASSERT( aArray );

    RImplInfoPtrArray *implInfoArray = static_cast<RImplInfoPtrArray*> ( aArray );

    implInfoArray->ResetAndDestroy();

    implInfoArray->Close();

    }

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

// CWlanBgScanAwsComms::StartAwsThreadL

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

//

void CWlanBgScanAwsComms::StartAwsThreadL()

    {

    DEBUG( "CWlanBgScanAwsComms::StartAwsThreadL()" );

    RImplInfoPtrArray awsImplArray;

    TCleanupItem awsImplArrayCleanup( CleanupEComArray, &awsImplArray );

    CleanupStack::PushL( awsImplArrayCleanup );

    CAwsEngineBase::ListImplementationsL( awsImplArray );

    if( awsImplArray.Count() == 0 )

        {

        DEBUG( "CWlanBgScanAwsComms::StartAwsThreadL() - no AWS implementation found" );

        User::Leave( KErrNotFound );

        }

    // first found AWS implementation will be taken into use

    iAwsImplInfo = static_cast<CImplementationInformation*>( awsImplArray[KFirstItemIndex] );

    awsImplArray.Remove( KFirstItemIndex );

    CleanupStack::PopAndDestroy( &awsImplArray ); //this causes a call to CleanupEComArray

    DEBUG( "CWlanBgScanAwsComms::StartAwsThreadL() - creating AWS thread" );

    RThread thread;

    TInt err = thread.Create( iAwsImplInfo->DisplayName(),

                                AwsThreadEntryPoint,

                                KDefaultStackSize,

                                KMinHeapSize,

                                KMaxHeapSize, 

                                reinterpret_cast<TAny*>( this ) );

    if( err != KErrNone)

        {

        DEBUG1( "CWlanBgScanAwsComms::StartAwsThreadL() - error: thread creation failed with error %i", err );

        delete iAwsImplInfo;

        iAwsImplInfo = NULL;

        User::Leave( err );

        }

    DEBUG( "CWlanBgScanAwsComms::StartAwsThreadL() - Resuming AWS thread" );

    thread.Resume();

    thread.Close();

    DEBUG( "CWlanBgScanAwsComms::StartAwsThreadL() - done" );    

    }

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

// CWlanBgScanAwsComms::AwsThreadEntryPoint

//

// This method is executing in the context of the AWS thread.

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

//

TInt CWlanBgScanAwsComms::AwsThreadEntryPoint( TAny* aThisPtr )

    {

    DEBUG("CWlanBgScanAwsComms::AwsThreadEntryPoint()");

    CWlanBgScanAwsComms* self = static_cast<CWlanBgScanAwsComms*>( aThisPtr );

    // create cleanup stack

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if ( cleanup == NULL )

        {

        DEBUG("CWlanBgScanAwsComms::AwsThreadEntryPoint() - error: Cleanup stack creation failed");

        User::Exit( KErrNoMemory );

        }

    __UHEAP_MARK;

    TRAPD( err, self->InstantiateAwsPluginL() );

    if ( err != KErrNone )

        {

        DEBUG1("CWlanBgScanAwsComms::AwsThreadEntryPoint() - AWS instantiation leaved with code %i", err);

        }

    __UHEAP_MARKEND;

    delete cleanup;

    cleanup = NULL;

    return KErrNone;    

    }

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

// CWlanBgScanAwsComms::InstantiateAwsPluginL

//

// This method is executing in the context of the AWS thread.

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

//

void CWlanBgScanAwsComms::InstantiateAwsPluginL()

    {

    DEBUG("CWlanBgScanAwsComms::InstantiateAwsPluginL()");

    ASSERT( iAwsImplInfo );

    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

    CleanupStack::PushL( scheduler );

    CActiveScheduler::Install( scheduler );

    DEBUG( "CWlanBgScanAwsComms::InstantiateAwsPluginL() - trying to instantiate AWS implementation:" );

    DEBUG1( "CWlanBgScanAwsComms::InstantiateAwsPluginL() - ImplementationUid:  0x%08X", iAwsImplInfo->ImplementationUid().iUid );

#ifdef _DEBUG

    TBuf8<KPrintLineLength> buf8;

    buf8.Copy( iAwsImplInfo->DisplayName() );

#endif

    DEBUG1S("CWlanBgScanAwsComms::InstantiateAwsPluginL() - DisplayName:        ", buf8.Length(), buf8.Ptr() );

    DEBUG1( "CWlanBgScanAwsComms::InstantiateAwsPluginL() - Version:            %i", iAwsImplInfo->Version() );

    DEBUG1S("CWlanBgScanAwsComms::InstantiateAwsPluginL() - DataType:           ", iAwsImplInfo->DataType().Length(), iAwsImplInfo->DataType().Ptr() );

    DEBUG1S("CWlanBgScanAwsComms::InstantiateAwsPluginL() - OpaqueData:         ", iAwsImplInfo->OpaqueData().Length(), iAwsImplInfo->OpaqueData().Ptr() );

    DEBUG1( "CWlanBgScanAwsComms::InstantiateAwsPluginL() - RomOnly:            %i", iAwsImplInfo->RomOnly() );

    DEBUG1( "CWlanBgScanAwsComms::InstantiateAwsPluginL() - RomBased:           %i", iAwsImplInfo->RomBased() );

    DEBUG1( "CWlanBgScanAwsComms::InstantiateAwsPluginL() - VendorId:           0x%08X", iAwsImplInfo->VendorId().iId );

    CAwsEngineBase::TAwsEngineConstructionParameters params = { this, KBgScanVersion, iAwsVersion };

    iAws = CAwsEngineBase::NewL( iAwsImplInfo->ImplementationUid().iUid, &params );

    DEBUG1( "CWlanBgScanAwsComms::InstantiateAwsPluginL() - AWS instantiated OK, iAwsVersion %u", iAwsVersion );

    iAwsOk = ETrue;

    __e32_memory_barrier();

    DEBUG( "CWlanBgScanAwsComms::InstantiateAwsPluginL() - data members synchronized" );

    DEBUG( "CWlanBgScanAwsComms::InstantiateAwsPluginL() - starting active scheduler - AWS is now in control of this thread" );

    CActiveScheduler::Start();

    // Thread execution will stay in CActiveScheduler::Start() until active scheduler is stopped

    DEBUG("CWlanBgScanAwsComms::InstantiateAwsPluginL() - active scheduler stopped" );

    // clean up

    delete iAws;

    iAws = NULL;

    CleanupStack::PopAndDestroy( scheduler );

    DEBUG( "CWlanBgScanAwsComms::InstantiateAwsPluginL() - exiting..." );

    User::Exit( KErrNone );

    }

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

// From class MAwsBgScanProvider.

// CWlanBgScanAwsComms::SetInterval

//

// This method is executing in the context of the AWS thread.

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

//

void CWlanBgScanAwsComms::SetInterval( TUint32 aNewInterval, TRequestStatus& aStatus )

    {

    DEBUG1( "CWlanBgScanAwsComms::SetInterval() - new interval %u", aNewInterval );

    iCommandHandler->CommandQueue( CWlanBgScanCommand::ESetInterval, aNewInterval, aStatus );

    DEBUG( "CWlanBgScanAwsComms::SetInterval() - returning" );    

    }

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

// CWlanBgScanAwsComms::SendOrQueueAwsCommand

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

//

void CWlanBgScanAwsComms::SendOrQueueAwsCommand( TAwsMessage& aMessage )

    {

    DEBUG1( "CWlanBgScanAwsComms::SendOrQueueAwsCommand( command %u )", aMessage.iCmd );

    // if a request is pending, queue the new command

    if( iStatus.Int() == KRequestPending )

        {

        DEBUG( "CWlanBgScanAwsComms::SendOrQueueAwsCommand() - request pending -> queue new command" );

        // store command to queue

        TInt err = iAwsMsgQueue.Append( aMessage );

        if( KErrNone == err )

            {

            DEBUG( "CWlanBgScanAwsComms::SendOrQueueAwsCommand() - command queued successfully" );

            }

        else

            {

            DEBUG( "CWlanBgScanAwsComms::SendOrQueueAwsCommand() - command queueing failed" );

            }

        return;

        }

    SendAwsCommand( aMessage );

    DEBUG( "CWlanBgScanAwsComms::SendOrQueueAwsCommand() - done" );

    }

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

// CWlanBgScanAwsComms::SendAwsCommand

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

//

void CWlanBgScanAwsComms::SendAwsCommand( TAwsMessage& aMessage )

    {

    DEBUG1( "CWlanBgScanAwsComms::SendAwsCommand( command %u )", aMessage.iCmd );

    if( !iAws )

        {

        DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - error: no AWS present!" );

        ASSERT( 0 );

        return;

        }

    DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - sending command" );

    switch( aMessage.iCmd )

        {

        case EStart:

            {

            iPendingCommand = EStart;

            iAws->Start( iStatus );

            SetActive();

            DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - EStart command sent" );

            break;

            }

        case EStop:

            {

            iPendingCommand = EStop;

            iAws->Stop( iStatus );

            SetActive();

            DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - EStop command sent" );

            break;

            }

        case ESetPowerSaveMode:

            {

            iPendingCommand = ESetPowerSaveMode;

            iAws->SetPowerSaveMode( static_cast<TAwsPsMode>( aMessage.iParameter ), iStatus );

            SetActive();

            DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - ESetPowerSaveMode command sent" );

            break;

            }

        default:

            {

            iPendingCommand = EAwsCommandMax;

            DEBUG1( "CWlanBgScanAwsComms::SendAwsCommand() - unknown command %u", aMessage.iCmd );

            ASSERT( 0 );

            }

        }

    DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - done" );

    }

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

// CWlanBgScanAwsComms::RunL

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

//

void CWlanBgScanAwsComms::RunL()

    {   

    DEBUG2( "CWlanBgScanAwsComms::RunL() - command: %u, completion status: %d", iPendingCommand, iStatus.Int() );

    TAwsMessage cmd = { EAwsCommandMax, NULL };

    // if there are more commands, send the next one

    if( iAwsMsgQueue.Count() )

        {

        cmd = static_cast<TAwsMessage> ( iAwsMsgQueue[KFirstItemIndex] );

        iAwsMsgQueue.Remove( KFirstItemIndex );

        SendAwsCommand( cmd );

        }

    }

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

// CWlanBgScanAwsComms::DoCancel

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

//

void CWlanBgScanAwsComms::DoCancel()

    {

    DEBUG( "CWlanBgScanAwsComms::DoCancel()" );

    }

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

// CWlanBgScanAwsComms::RunError

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

//

TInt CWlanBgScanAwsComms::RunError( TInt aError )

    {

    DEBUG1( "CWlanBgScanAwsComms::RunError( %d )", aError );

    return aError;

    }

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

// CWlanBgScanAwsComms::DoSetInterval

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

//

void CWlanBgScanAwsComms::DoSetInterval( TUint32 aNewInterval )

    {

    DEBUG1( "CWlanBgScanAwsComms::DoSetInterval( aNewInterval: %u )", aNewInterval );

    iBgScan.DoSetInterval( aNewInterval );

    }

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

// CWlanBgScanAwsComms::IsAwsPresent

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

//

TBool CWlanBgScanAwsComms::IsAwsPresent()

    {

    DEBUG1( "CWlanBgScanAwsComms::IsAwsPresent() - returning %d", iAwsOk );

    return iAwsOk;

    }