/*

* 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:  Diagnostics Framework Plug-in to test network coverage on

                  the currently locked channel.

*

*/

// CLASS DECLARATION

#include "diagnetcoverageplugin.h"

// SYSTEM INCLUDE FILES

#include <centralrepository.h>

#include <StringLoader.h>               // StringLoader

#include <DiagTestObserver.h>           // MDiagTestObserver

#include <DiagTestExecParam.h>          // TDiagTestExecParam

#include <DiagResultsDbItemBuilder.h>   // CDiagResultsDbItemBuilder

#include <DiagResultDetailBasic.h>      // CDiagResultDetailBasic

#include <DiagFrameworkDebug.h>         // LOGSTRING

#include <devdiagnetcoveragepluginrsc.rsg>

// USER INCLUDE FILES

#include "diagnetcoveragepluginprivatecrkeys.h"

// ADO & Platformization Changes

#include <DiagFrameworkDebug.h>                     // debug macros

#include <DiagEngineCommon.h>                       // MDiagEngineCommon

#include <DiagCommonDialog.h> 

#include <AknDialog.h> // ADO & Platformization Changes

#include <aknmessagequerydialog.h>  // ADO & Platformization Changes

#include <DiagPluginExecPlan.h>

#include <DiagExecPlanEntry.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

static const TInt KTotalTestSteps = 2;

_LIT( KDiagNetCoveragePluginResourceFileName, "z:DevDiagNetCoveragePluginRsc.rsc" );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CDiagNetCoveragePlugin::CDiagNetCoveragePlugin()

//

// Constructor

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

//

CDiagNetCoveragePlugin::CDiagNetCoveragePlugin( CDiagPluginConstructionParam* aParam )

    :   CDiagTestPluginBase( aParam ),

        iNetworkInfoV1(),

        iSignalStrengthV1(),

        iNetworkInfoV1Pckg( iNetworkInfoV1 ),

        iSignalStrengthV1Pckg( iSignalStrengthV1 )

    {

    }

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

// CDiagNetCoveragePlugin::NewL()

//

// Symbian OS default constructor

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

MDiagPlugin* CDiagNetCoveragePlugin::NewL( TAny* aInitParams )

    {

    LOGSTRING( "CDiagNetCoveragePlugin::NewL" )

    ASSERT( aInitParams != NULL );

    CDiagPluginConstructionParam* param = 

            static_cast<CDiagPluginConstructionParam*>( aInitParams );

    CleanupStack::PushL( param );

    CDiagNetCoveragePlugin* self = new( ELeave ) CDiagNetCoveragePlugin( param );

    CleanupStack::Pop( param );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CDiagNetCoveragePlugin::ConstructL()

//

// Symbian OS two-phased constructor

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

void CDiagNetCoveragePlugin::ConstructL()

    {

    LOGSTRING("CDiagNetCoveragePlugin::ConstructL");        

    BaseConstructL( KDiagNetCoveragePluginResourceFileName );

    ReadThresholdValuesL();                

    idialogOn = EFalse;              

    }

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

// CDiagNetCoveragePlugin::~CDiagNetCoveragePlugin

//

// Destructor

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

CDiagNetCoveragePlugin::~CDiagNetCoveragePlugin()

    {

    // Base class will call StopAndCleanup(), which callso

    //  Cancel() -> DoCancel()

    //  DoStopAndCleanupL()

    if ( iWaitDialog )

    delete iWaitDialog;

    }

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

// From MDiagPlugin

// CDiagNetCoveragePlugin::IsVisible()

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

TBool CDiagNetCoveragePlugin::IsVisible() const

    {

    return ETrue;

    }

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

// From MDiagTestPlugin

// CDiagNetCoveragePlugin::RunMode()

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

MDiagTestPlugin::TRunMode CDiagNetCoveragePlugin::RunMode() const

    {

    return EAutomatic;

    }

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

// From MDiagTestPlugin

// CDiagNetCoveragePlugin::TotalSteps()

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

TUint CDiagNetCoveragePlugin::TotalSteps() const

    {

    return KTotalTestSteps;

    }

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

// From MDiagPlugin

// CDiagNetCoveragePlugin::GetPluginNameL

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

HBufC* CDiagNetCoveragePlugin::GetPluginNameL( TNameLayoutType aLayoutType ) const

    {

    switch ( aLayoutType )

        {

        case ENameLayoutListSingle:

            return StringLoader::LoadL ( R_DIAG_NET_COVERAGE_PLUGIN_NAME );       

        case ENameLayoutHeadingPane:

             return StringLoader::LoadL ( R_QTN_DIAG_MSG_TITLE_VOICE_NETWORK );

        case ENameLayoutPopupInfoPane:

              return StringLoader::LoadL ( R_QTN_DIAG_MSG_INFO_VOICE_NETWORK );

        case ENameLayoutTitlePane:

             return StringLoader::LoadL ( R_QTN_DIAG_TITLE_TEST_VOICE_NETWORK );

        case ENameLayoutListSingleGraphic:

             return StringLoader::LoadL ( R_QTN_DIAG_LST_TEST_VOICE_NETWORK );

        default:

            LOGSTRING2( "CDiagNetCoveragePlugin::GetPluginNameL: "

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

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

            return StringLoader::LoadL ( R_DIAG_NET_COVERAGE_PLUGIN_NAME );

        }

    }

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

// From MDiagPlugin

// CDiagNetCoveragePlugin::Uid

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

TUid CDiagNetCoveragePlugin::Uid() const

    {

    return KDiagNetCoveragePluginUid;

    }

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

// From CActive

// CDiagNetCoveragePlugin::RunL

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

void CDiagNetCoveragePlugin::RunL()

    {

    ReportTestProgressL( iProgressCounter++ );

    switch (iState)

        {

        case EStateWaitForBandType:                    

            CheckNetworkAccessL();

            break;

        case EStateWaitForSignalStrength:

            CheckSignalStrengthL();                      

            break;

		case EStateTestCancel:

			 CompleteTestL( CDiagResultsDatabaseItem::ESkipped );

			 break;

        default:

            // Unsupported state

            ASSERT(0);

            break;

        }

    }  

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

// CDiagNetCoveragePlugin::RunError

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

//

TInt CDiagNetCoveragePlugin::RunError( TInt aError )

	{

		LOGSTRING2( "CDiagNetCoveragePlugin::RunError( %d )", aError )    

		return KErrNone;

	}

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

// From CActive

// CDiagNetCoveragePlugin::DoCancel

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

void CDiagNetCoveragePlugin::DoCancel()

    {   

    LOGSTRING("CDiagNetCoveragePlugin::DoCancel");

    TInt result;

    // Cancel request to CTelephony

    switch ( iState )    

        {

        case EStateWaitForBandType:                                

            result = iTelephony->CancelAsync( CTelephony::EGetCurrentNetworkInfoCancel );

            ASSERT( result == KErrNone );

            break;

        case EStateWaitForSignalStrength:

            result = iTelephony->CancelAsync( CTelephony::EGetSignalStrengthCancel );

            ASSERT( result == KErrNone );

            break;

        default:

            // No cancel needed

            if (result == KErrNone)

            LOGSTRING("docancel() result");

            break;

        }                             

    }    

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

// From CDiagTestPluginBase

// CDiagNetCoveragePlugin::DoRunTestL()

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

void CDiagNetCoveragePlugin::DoRunTestL()

    {

    LOGSTRING("CDiagNetCoveragePlugin::DoRunTestL");

     // ADO & Platformization Changes

    if(!(ExecutionParam().Engine().ExecutionPlanL().CurrentExecutionItem().AsDependency()))

    {

    TInt aButtonId;

    ShowMessageQueryL(R_DIAG_MESSAGEQUERY_TITLE_NETCOVERAGE,aButtonId);

    if(aButtonId == ENetcoverageTestCancel)

    	{

    	CompleteTestL( CDiagResultsDatabaseItem::ESkipped );

        return;

    	}

    if(aButtonId == ENetcoverageTestSkip)

    	{

		TInt confirmResult = 0;

        CAknDialog* dlg = ExecutionParam().Engine().

        CreateCommonDialogLC( EDiagCommonDialogConfirmSkipAll, NULL );

        if ( !RunWaitingDialogL(dlg, confirmResult ) )

            {

            return;

            }

        if (confirmResult)

            {

            return;

            }

    	}

    }

    // Changes Ends

    iProgressCounter = 1;

    iNetworkType = ETypeUnknown;

    iNetworkBand = EBandUnknown;

    // ones to use because they are less strict

    iNetworkBand = EBand1800_1900_2100;

    ObtainBandTypeAsyncL();

    // Wait note display only if itz not a dependency execution.

    if(!(ExecutionParam().Engine().ExecutionPlanL().CurrentExecutionItem().AsDependency()))

    ShowProgressNoteL();

    }     

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

// CDiagNetCoveragePlugin::DoStopAndCleanupL()

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

void CDiagNetCoveragePlugin::DoStopAndCleanupL()

    {    

    LOGSTRING("CDiagNetCoveragePlugin::DoStopAndCleanupL");

    delete iTelephony;

    iTelephony = NULL;

    idialogOn = EFalse;   

    iState = EStateTestCompleted;            

    }

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

// CDiagNetCoveragePlugin::ObtainBandTypeAsyncL()

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

void CDiagNetCoveragePlugin::ObtainBandTypeAsyncL()

    {    

    LOGSTRING("CDiagNetCoveragePlugin::ObtainBandTypeAsyncL");

    ASSERT( iTelephony == NULL );

    iTelephony = CTelephony::NewL();    

    iTelephony->GetCurrentNetworkInfo( iStatus, iNetworkInfoV1Pckg );

    iState = EStateWaitForBandType;

    SetActive();    

    }

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

// CDiagNetCoveragePlugin::ReadThresholdValuesL()

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

void CDiagNetCoveragePlugin::ReadThresholdValuesL()

    {

    LOGSTRING("CDiagNetCoveragePlugin::ReadThresholdValuesL");

    CRepository* repository = CRepository::NewLC( KCRUidNetworkCoverage );       

    LOGSTRING("CDiagNetCoveragePlugin::ReadThresholdValuesL:");

    User::LeaveIfError( repository->Get(KPhoneDoctorGSM850SigStrThreshold, 

                            iThresholdValues[ETypeGSM][EBand900_850]) );

    LOGSTRING2("\tKPhoneDoctorGSM850SigStrThreshold=%.2f",iThresholdValues[ETypeGSM][EBand900_850]);

    User::LeaveIfError( repository->Get(KPhoneDoctorGSM1900SigStrThreshold, 

                            iThresholdValues[ETypeGSM][EBand1800_1900_2100]) );

    LOGSTRING2("\tKPhoneDoctorGSM1900SigStrThreshold=%.2f",iThresholdValues[ETypeGSM][EBand1800_1900_2100]);

    User::LeaveIfError( repository->Get(KPhoneDoctorUMTS850SigStrThreshold, 

                            iThresholdValues[ETypeUMTS][EBand900_850]) );

    LOGSTRING2("\tKPhoneDoctorUMTS850SigStrThreshold=%.2f",iThresholdValues[ETypeUMTS][EBand900_850]);

    User::LeaveIfError( repository->Get(KPhoneDoctorUMTS1900SigStrThreshold, 

                            iThresholdValues[ETypeUMTS][EBand1800_1900_2100]) );

    LOGSTRING2("\tKPhoneDoctorUMTS1900SigStrThreshold=%.2f",iThresholdValues[ETypeUMTS][EBand1800_1900_2100]);

    CleanupStack::PopAndDestroy(repository);

    }

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

// From CActive

// CDiagNetCoveragePlugin::CheckNetworkAccessL

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

void CDiagNetCoveragePlugin::CheckNetworkAccessL()

    {        

    if ( iStatus != KErrNone)

        {                                                 

        LOGSTRING2("CDiagNetCoveragePlugin::CheckNetworkAccessL: "

            L"Error obtaining network access type %d", iStatus.Int() );

        if (idialogOn)

        iWaitDialog->ProcessFinishedL();

        CompleteTestL( CDiagResultsDatabaseItem::EFailed );

        }

    else

        {

        LOGSTRING("CDiagNetCoveragePlugin::CheckNetworkAccessL: Got Network Access Type");                

        // Set network band

        switch (iNetworkInfoV1.iAccess)

            {

            // This is used when there is no network activity and therefore no RAT active.

            case CTelephony::ENetworkAccessUnknown:

                LOGSTRING("  ENetworkAccessUnknown"); 

#ifdef __WINS__

                // Fake network type for testing purposes

                iNetworkType = ETypeGSM;

#else               

                if (idialogOn)

                iWaitDialog->ProcessFinishedL();

                CompleteTestL( CDiagResultsDatabaseItem::EFailed );

#endif

                break;

            // The access technology is GSM.

            case CTelephony::ENetworkAccessGsm: 

                // FALL THROUGH

            // The access technology is GSM COMPACT. However GSM COMPACT systems 

            // which use GSM frequency bands but with the CBPCCH broadcast channel

            // are considered as a separate access technology from GSM.

            case CTelephony::ENetworkAccessGsmCompact:

                LOGSTRING("  ENetworkAccessGsm");                 

                iNetworkType = ETypeGSM;

                break;

            // The access technology is UTRAN (UMTS Network).

            case CTelephony::ENetworkAccessUtran:

                LOGSTRING("  ENetworkAccessUtran");                 

                iNetworkType = ETypeUMTS;

                break;

            default: // Unexpected

                ASSERT(0);

                break;

            }

        // If test did not fail, obtain signal strength

        if ( iState == EStateWaitForBandType )

            {                

            iTelephony->GetSignalStrength(iStatus,iSignalStrengthV1Pckg);

            iState = EStateWaitForSignalStrength;

            SetActive();            

            }

        }                                                         

    }

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

// CDiagNetCoveragePlugin::CheckSignalStrengthL

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

void CDiagNetCoveragePlugin::CheckSignalStrengthL()

    {

    CDiagResultsDatabaseItem::TResult result = CDiagResultsDatabaseItem::EFailed;

    LOGSTRING2("CDiagNetCoveragePlugin::CheckSignalStrengthL Status %d",iStatus.Int());   

    if (iStatus.Int() == KErrNone)  

        {

        TReal sigStrength = -iSignalStrengthV1.iSignalStrength;           

        LOGSTRING3("CDiagNetCoveragePlugin::CheckSignalStrengthL: Got Signal Strength=%d bars, %.2f DBm",

                (TInt)iSignalStrengthV1.iBar,

                sigStrength);

        LOGSTRING3("CDiagNetCoveragePlugin::CheckSignalStrengthL: Network type = %d, band = %d",iNetworkType,iNetworkBand);                            

        TReal threshold = iThresholdValues[iNetworkType][iNetworkBand];

        LOGSTRING2("CDiagNetCoveragePlugin::CheckSignalStrengthL: Threshold is %.2f",threshold);

        // Use band/type to index into threshold array and check

        // signal strength.  If there is no signal, Dbm will be 0, which is actually

        // quite high, so check bars to cover this scenario.

        if ( ( sigStrength >= threshold ) && ( iSignalStrengthV1.iBar ) )

            {                        

            result = CDiagResultsDatabaseItem::ESuccess;

            }          

        }

        else

        {            

            LOGSTRING2("CDiagNetCoveragePlugin::CheckSignalStrengthL: Signal strength error %d",iStatus.Int());

        }      

    if (idialogOn)                       

    iWaitDialog->ProcessFinishedL();

    CompleteTestL( result );

    // End of Test

    }      

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

// CDiagNetCoveragePlugin::Panic

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

void CDiagNetCoveragePlugin::Panic(TInt aPanicCode)

    {

    _LIT(KDiagNetCoverageCategory,"Diag-NetCoverage");

    User::Panic(KDiagNetCoverageCategory, aPanicCode);

    }

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

// CDiagNetCoveragePlugin::ShowProgressNoteL

//

// wait Note

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

void CDiagNetCoveragePlugin::ShowProgressNoteL()

    {

	if ( iWaitDialog )

	{