/*

* 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:  This is the class module for the Diagnostics USB Cable Test plugin

*

*/

// INCLUDE FILES

// Class Declaration

#include "diagusbcabletestplugin.h"

// System includes

#include <avkon.hrh>                        // command definitions

#include <StringLoader.h>                   // StringLoader

#include <aknmessagequerydialog.h>     		// CAknMessageQueryDialog

#include <DiagFrameworkDebug.h>             // Debug macros

#include <DiagTestExecParam.h>              // TDiagTestExecParam

#include <DiagEngineCommon.h>               // MDiagEngineCommon

#include <devdiagusbcabletestpluginrsc.rsg>    // resources

// User includes

#include "diagusbcabletestengine.h"         // CDiagUSBCableTestEngine

#include "diagusbcabletestplugin.hrh"       // UIDs and command ids

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TUint KTotalNumOfSteps = 2;

const TUid KDiagUSBCableTestPluginUid = { _IMPLEMENTATION_UID };

_LIT( KDiagUSBCableTestPluginResourceFileName, "z:DevDiagUSBCableTestPluginRsc.rsc" );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ==============================

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

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

// Constructor

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

//

CDiagUSBCableTestPlugin::CDiagUSBCableTestPlugin

                                  ( CDiagPluginConstructionParam* aParam )

    : CDiagTestPluginBase( aParam )

    {

    LOGSTRING( "CDiagUSBCableTestPlugin::CDiagUSBCableTestPlugin()" )

    }

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

// Symbian OS default constructor

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

MDiagPlugin* CDiagUSBCableTestPlugin::NewL( TAny* aInitParams )

    {

    LOGSTRING( "CDiagUSBCableTestPlugin::NewL()" )

    CDiagPluginConstructionParam* param = 

            static_cast<CDiagPluginConstructionParam*>(aInitParams);

    CleanupStack::PushL( param );

    CDiagUSBCableTestPlugin* self = 

            new( ELeave ) CDiagUSBCableTestPlugin (param);

    CleanupStack::Pop( param );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Symbian OS second phase constructor

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

void CDiagUSBCableTestPlugin::ConstructL()

    {

    LOGSTRING( "CDiagUSBCableTestPlugin::ConstructL()" )

    BaseConstructL ( KDiagUSBCableTestPluginResourceFileName );

    }

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

// Destructor

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

CDiagUSBCableTestPlugin::~CDiagUSBCableTestPlugin()

    {

    LOGSTRING( "CDiagUSBCableTestPlugin::~CDiagUSBCableTestPlugin()" )

    // StopAndCleanupL() called by base class, whcih calls

    //  Cancel()    -> DoCancel()

    //  DoStopAndCleanupL()

    // Not much to do here.

    }

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

// From MDiagPlugin

// CDiagUSBCableTestPlugin::IsVisible()

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

TBool CDiagUSBCableTestPlugin::IsVisible() const

    {

    return ETrue;

    }

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

// From MDiagTestPlugin

// CDiagUSBCableTestPlugin::RunMode()

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

MDiagTestPlugin::TRunMode CDiagUSBCableTestPlugin::RunMode() const

    {

    return EInteractiveDialog;

    }

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

// From MDiagTestPlugin

// CDiagUSBCableTestPlugin::TotalSteps()

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

TUint CDiagUSBCableTestPlugin::TotalSteps() const

    {

    return KTotalNumOfSteps;

    }

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

// From MDiagPlugin

// CDiagUSBCableTestPlugin::GetPluginName

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

HBufC* CDiagUSBCableTestPlugin::GetPluginNameL( TNameLayoutType aLayoutType ) const

    {

    switch ( aLayoutType )

        {

        case ENameLayoutHeadingPane:

            return StringLoader::LoadL( R_DIAG_USB_CABLE_TEST_HEADING_PANE );

        case ENameLayoutPopupInfoPane:

            return StringLoader::LoadL( R_DIAG_USB_CABLE_TEST_POPUP_INFO_PANE );

        case ENameLayoutTitlePane:

            return StringLoader::LoadL( R_DIAG_USB_CABLE_TEST_TITLE_PANE );

        case ENameLayoutListSingleGraphic:

            return StringLoader::LoadL( R_DIAG_USB_CABLE_TEST_SINGLE_GRAPHIC  );        

        case ENameLayoutListSingle:

            return StringLoader::LoadL ( R_DIAG_USB_CABLE_TEST_SINGLE ); 

        default:

            LOGSTRING2( "CDiagUSBCableTestPlugin::GetPluginNameL: "

                L"ERROR: Unsupported layout type %d", aLayoutType )

            __ASSERT_DEBUG( 0, User::Invariant() );

            return StringLoader::LoadL ( R_DIAG_USB_CABLE_TEST_SINGLE );

        }

    }

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

// From MDiagPlugin

// CDiagUSBCableTestPlugin::Uid

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

TUid CDiagUSBCableTestPlugin::Uid() const

    {

    return KDiagUSBCableTestPluginUid;

    }

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

// From CActive

// CDiagUSBCableTestPlugin::RunL

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

void CDiagUSBCableTestPlugin::RunL()

    {

    // nothing to do here

    }

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

// From CActive

// CDiagUSBCableTestPlugin::DoCancel

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

void CDiagUSBCableTestPlugin::DoCancel()

    {

    // nothing to do here

    }

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

// From CDiagTestPluginBase

// CDiagUSBCableTestPlugin::DoRunTestL()

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

void CDiagUSBCableTestPlugin::DoRunTestL()

    {

    LOGSTRING( "CDiagUSBCableTestPlugin::DoRunTestL() Test execution begins here." )

    // ADO & Platformization Changes

    CAknMessageQueryDialog* dlg    = NULL;

    TInt aButtonId,result;

    // code ends

    // Run USB Cable Test

    ASSERT( iEngine == NULL );

    // ADO & Platformization Changes

	dlg = new ( ELeave ) CAknMessageQueryDialog();

    dlg->PrepareLC(R_MESSAGEQUERY_TITLE );

    if(SinglePluginExecution())

        {

        CEikButtonGroupContainer& cba = dlg->ButtonGroupContainer();

        cba.SetCommandSetL(R_DIAG_USB_SOFTKEYS_CANCEL__OK);

        }

	result = RunWaitingDialogL( dlg, aButtonId );

	if (result == KErrNone)

	{

	LOGSTRING("RunWaitingDialogL return = true");

	}

	if(aButtonId == EUsbTestConnectUSBCancel )

		{

		CompleteTestL( CDiagResultsDatabaseItem::ECancelled );

		return;	

		}

   if(aButtonId == EUsbTestConnectUSBSkip )

        {

        TInt aUserResponse;

        TInt aResponseType;

        TInt aOption = 0;

        aResponseType = AskCancelExecutionL(aUserResponse,aOption);

        if(!aResponseType)

            return;

        if (aUserResponse)

               { 

               return;

               }

        }

	// ADO & Platformization Changes

    iEngine = CDiagUSBCableTestEngine::NewL(*this, SinglePluginExecution() );

    iEngine->RunUSBCableTestL();

    }

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

// From CDiagTestPluginBase

// CDiagUSBCableTestPlugin::DoStopAndCleanupL()

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

void CDiagUSBCableTestPlugin::DoStopAndCleanupL()

    {

    LOGSTRING( "CDiagUSBCableTestPlugin::DoStopAndCleanupL()." )

    delete iEngine;

    iEngine = NULL;

    }

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

// From MDiagUSBTestReportResultInterface

// CDiagUSBCableTestPlugin::ReportTestResultL()

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

void CDiagUSBCableTestPlugin::ReportTestResultL(

                                    CDiagResultsDatabaseItem::TResult aResult)

    {

    CompleteTestL( aResult );

    }

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

// The engine class uses this callback on the plugin class to ask the user if 

// the entire test execution needs to be cancelled.

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

TBool CDiagUSBCableTestPlugin::AskCancelExecutionL(TInt& aUserResponse, TInt aOption)

    {

    CAknDialog* cancelDialog = NULL;

    if(aOption == 0)

        {

        cancelDialog = ExecutionParam().Engine().

                   CreateCommonDialogLC( EDiagCommonDialogConfirmSkipAll, NULL );

        }

    else

        {

        cancelDialog = ExecutionParam().Engine().

                           CreateCommonDialogLC( EDiagCommonDialogConfirmCancelAll, NULL);

        }

    return RunWaitingDialogL( cancelDialog, aUserResponse );

    }    

// End of File