/*

* Copyright (c) 2002 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:  ?Description

*

*/

// INCLUDE FILES

#include <e32math.h>

#include <e32base.h>

#include <s32mem.h>

#include <e32property.h>

#include <AccMonitorInfo.h>

#include <AccMonitor.h>

#include <AccMonitorCapabilities.h>

#include <AccMonConnectionEmulator.h>

#include <AccMonTestTimer.h>

#include "accMonitoringTestModule.h"

#include "acc_debug.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

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

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

// CAccMonitoringTestModule::Case

// Returns a test case by number.

//

// This function contains an array of all available test cases 

// i.e pair of case name and test function. If case specified by parameter

// aCaseNumber is found from array, then that item is returned.

// 

// The reason for this rather complicated function is to specify all the

// test cases only in one place. It is not necessary to understand how

// function pointers to class member functions works when adding new test

// cases. See function body for instructions how to add new test case.

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

//

const TCaseInfo CAccMonitoringTestModule::Case ( 

    const TInt aCaseNumber ) const 

     {

    /**

    * To add new test cases, implement new test case function and add new 

    * line to KCases array specify the name of the case and the function 

    * doing the test case

    * In practice, do following

    * 1) Make copy of existing test case function and change its name

    *    and functionality. Note that the function must be added to 

    *    headsetTestModule.cpp file and to headsetTestModule.h 

    *    header file.

    *

    * 2) Add entry to following KCases array either by using:

    *

    * 2.1: FUNCENTRY or ENTRY macro

    * ENTRY macro takes two parameters: test case name and test case 

    * function name.

    *

    * FUNCENTRY macro takes only test case function name as a parameter and

    * uses that as a test case name and test case function name.

    *

    * Or

    *

    * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used

    * only with OOM (Out-Of-Memory) testing!

    *

    * OOM_ENTRY macro takes five parameters: test case name, test case 

    * function name, TBool which specifies is method supposed to be run using

    * OOM conditions, TInt value for first heap memory allocation failure and 

    * TInt value for last heap memory allocation failure.

    * 

    * OOM_FUNCENTRY macro takes test case function name as a parameter and uses

    * that as a test case name, TBool which specifies is method supposed to be

    * run using OOM conditions, TInt value for first heap memory allocation 

    * failure and TInt value for last heap memory allocation failure. 

    */ 

    static TCaseInfoInternal const KCases[] =

        {

        // To add new test cases, add new items to this array

        };

    // Verify that case number is valid

    if( (TUint) aCaseNumber >= sizeof( KCases ) / 

                               sizeof( TCaseInfoInternal ) )

        {

        // Invalid case, construct empty object

        TCaseInfo null( (const TText*) L"" );

        null.iMethod = NULL;

        null.iIsOOMTest = EFalse;

        null.iFirstMemoryAllocation = 0;

        null.iLastMemoryAllocation = 0;

        return null;

        } 

    // Construct TCaseInfo object and return it

    TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

    tmp.iMethod = KCases[ aCaseNumber ].iMethod;

    tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;

    tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;

    tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;

    return tmp;

    }

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

// CAccMonitoringTestModule::AccMonitoringStatusChangedL

// Get the information from the connected accessory. Inherited from 

// MAccMonitorObserver. After receiving information stop Active Scheduler.

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

//							   

void CAccMonitoringTestModule::ConnectedL( CAccMonitorInfo* aInfo )

    {

    if( iLeaveFlag )

    	{

    	User::Leave( KErrGeneral );

    	}

    else

    	{

    	/**

	    * Get the capabilities from the connected accessory and store 'em to 

	    * iConnectedAccessory

	    */

	    iConnectedAccessory->CopyL( aInfo );

	    if( iTestTimer->IsActive() )

	    	{

	    	iTestTimer->Cancel();

	    	}

	 	// Stop the scheduler

	 	CActiveScheduler::Stop();

    	}

    }

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

// CAccMonitoringTestModule::AccMonitoringStatusChangedL

// Get the information from the disconnected accessory. Inherited from 

// MAccMonitorObserver. After receiving information stop Active Scheduler.

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

//							   

void CAccMonitoringTestModule::DisconnectedL( CAccMonitorInfo* aInfo )

    {

    /**

    * Get the capabilities from the connected accessory and store 'em to 

    * iConnectedAccessory

    */

    if( iTestTimer->IsActive() )

    	{

    	iTestTimer->Cancel();

    	}

    iConnectedAccessory->CopyL( aInfo );

 	// Stop the scheduler

    CActiveScheduler::Stop();

    }

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

// CAccMonitoringTestModule::HeadsetStatusError

// Test just that this function works.

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

//

void CAccMonitoringTestModule::AccMonitorObserverError( TInt /*aError*/ )

    {

    iRunErrorCheck = ETrue;

    if( iTestTimer->IsActive() )

	    {

	    iTestTimer->Cancel();

	    }

	iLeaveFlag = EFalse;

    // Stop the scheduler

 	CActiveScheduler::Stop();

    }

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

// CAccMonitoringTestModule::AccMonitorTestNoL

// A simple test which creates an instance of the CAccMonitor and uses

// GetConnectedAccessoriesL method. Expected result is KErrNotFound since no

// accessories are connected.

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

//

TInt CAccMonitoringTestModule::AccMonitorTestNoL( 

    TTestResult& aResult )

    {

    __UHEAP_MARK;

    // Create an instance of the CAccMonitor

    TInt err( 0 );

    CAccMonitor* api = CAccMonitor::NewLC();

    RConnectedAccessories array;

    CleanupClosePushL ( array );

    TInt amount;

    // Get the connected accessories, no accessories should be connected.

    amount = api->GetConnectedAccessoriesL( array );

    CAccMonitorInfo* info = CAccMonitorInfo::NewL();

    CleanupStack::PushL ( info );

    TRAPD( err1, api->StartObservingL( this, info ) );

    api->StopObserving();

    CleanupStack::PopAndDestroy( info );

    if( amount == KErrNone )

    	{

    	err = KErrNone;

    	_LIT( KDescription, "Function used properly, test passed");

    	aResult.SetResult( err, KDescription );

    	}

    else

    	{

    	err = KErrGeneral;

    	_LIT( KDescription, "Some accessory was connected or something went wrong, test failed" );

    	aResult.SetResult( err, KDescription );

    	}

    array.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &array );

    CleanupStack::PopAndDestroy( api );

    __UHEAP_MARKEND;

    // Case was executed

    return err;

    }

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

// CAccMonitoringTestModule::AccMonitorTestOneL

// A test to connect some accessory and then getting the information from 

// Accessory Monitoring API. The information is then checked to be correct.

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

//

TInt CAccMonitoringTestModule::AccMonitorTestOneL( 

    TTestResult& aResult )

    {

    __UHEAP_MARK;

    TInt amount;

    TInt err( 0 );

    // Connect a wired headset.

	CConnectionEmulator* con = CConnectionEmulator::NewL();

	CleanupStack::PushL( con );

	TBool sync( ETrue );

	TRAPD( conErr, con->ConnectAccessoryL( CConnectionEmulator::EWiredHeadSetCon, sync ) );

	RConnectedAccessories array;

    CleanupClosePushL( array );

	// Create an instance of the api.

    CAccMonitor* api = CAccMonitor::NewL();

    CleanupStack::PushL( api );

    // Get the connected accessories.

    err = GetConnectedAccessoriesL(api, array, amount);

    CleanupStack::PopAndDestroy( api );

    if( amount == 1 )

        {

        err = KErrNone;

        }

    else

        {

        err = KErrGeneral;

        }

    // Get information about the connected accessory to info instance.

    CAccMonitorInfo* info = CAccMonitorInfo::NewLC( array[ 0 ] );

    // Check if capabilities were correct.

    TBool result( EFalse );

    result = info->Exists( KAccMonHeadset );

    array.ResetAndDestroy();

    if( ( err == KErrNone ) && result )

    	{

    	_LIT( KDescription, "Accessory was connected, test passed" );

    	aResult.SetResult( err, KDescription );

    	}

    else

    	{

    	err = KErrNone;

    	_LIT( KDescription, "Something went wrong, test failed" );

    	aResult.SetResult( err, KDescription );

    	}

    CleanupStack::PopAndDestroy( info );

    // Disconnect the accessory that was connected.

    TRAPD( disconErr, con->DisconnectAccessoryL( CConnectionEmulator::EWiredHeadSetCon, sync ) );

    array.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &array );

    CleanupStack::PopAndDestroy( con );

	if( ( conErr != KErrNone ) && ( disconErr != KErrNone ) )

    	{

    	_LIT( KDescription, "Error in connection" );

    	if( conErr != KErrNone )

    		{

    		aResult.SetResult( conErr, KDescription );

    		}

    	else

    		{

    		aResult.SetResult( disconErr, KDescription );

    		}

    	}

	__UHEAP_MARKEND;

    // Case was executed

    return err;

    }

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

// CAccMonitoringTestModule::AccMonitorTestMultiL

// A test to connect multiple accessories and then getting the information from

// Accessory Monitoring API. The information is then checked to be correct.

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

//

TInt CAccMonitoringTestModule::AccMonitorTestMultiL( 

    TTestResult& aResult )

    {

    __UHEAP_MARK;

    TInt amount;

    TInt err;

    TInt disconErr( KErrNone );

    CConnectionEmulator* con = CConnectionEmulator::NewL();

	CleanupStack::PushL( con );

	TBool sync( ETrue );

	// Connect a wired headset

	TRAPD( conErr, con->ConnectAccessoryL( CConnectionEmulator::EWiredHeadSetCon, sync ) );

	// Connect a wireless headset

	//TRAPD( conErr1, con->ConnectAccessoryL( CConnectionEmulator::EWirelessHeadSetCon, sync ) );

    CAccMonitor* api = CAccMonitor::NewL();

    CleanupStack::PushL( api );

    RConnectedAccessories array;

    CleanupClosePushL( array );

    // Get the connected accessories from the API

    err = GetConnectedAccessoriesL(api, array, amount);

    TBool result( EFalse );

    // Check the connected accessories and disconnect after being checked.

    for( TInt i = 0; i != array.Count(); i++ )

    	{

    	CAccMonitorInfo* info = CAccMonitorInfo::NewLC( array[ i ] );

    	if( ( info->AccDeviceType() == KAccMonHeadset ) && ( info->AccPhysicalConnection() == KAccMonWired ) )

    		{

    		result = info->Exists( iWiredHeadsetAccessory );

    		}

    	if( ( info->AccDeviceType() == KAccMonHeadset ) && ( info->AccPhysicalConnection() == KAccMonBluetooth ) )

    		{

    		result = info->Exists( iWirelessHeadsetAccessory );

    		}

    	if( ( info->AccDeviceType() == KAccMonCarKit ) && ( info->AccPhysicalConnection() == KAccMonWired ) )

    		{

    		result = info->Exists( iWiredCarKitAccessory );

    		}

    	if( ( info->AccDeviceType() == KAccMonCarKit ) && ( info->AccPhysicalConnection() == KAccMonBluetooth ) )

    		{

    		result = info->Exists( iWirelessCarKitAccessory );

    		}

    	if( ( info->AccDeviceType() == KAccMonAVDevice ) && ( info->AccPhysicalConnection() == KAccMonWired ) )

    		{

    		result = info->Exists( iTVOutAccessory );

    		}

    	if( ( info->AccDeviceType() == KAccMonOffice ) && ( info->AccPhysicalConnection() == KAccMonWired ) )

    		{

    		result = info->Exists( iMusicStandAccessory );

    		}

    	if( !result )

    		{

    		break;

    		}

    	TRAPD( disconErr, con->DisconnectAccessoryL( info, sync ) );

    	CleanupStack::PopAndDestroy( info );

    	}

    array.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &array ); 

    CleanupStack::PopAndDestroy( api );

    CleanupStack::PopAndDestroy( con );       

    // Check result

    if( ( err == KErrNone ) && result )

    	{

    	_LIT( KDescription, "Accessory was connected, test passed" );

    	aResult.SetResult( err, KDescription );

    	}

    else

    	{

    	_LIT( KDescription, "Something went wrong, test failed" );

    	aResult.SetResult( err, KDescription );

    	}

    if( ( conErr != KErrNone ) && ( disconErr != KErrNone ) )

    	{

    	_LIT( KDescription, "Error in connection" );

    	if( conErr != KErrNone )

    		{

    		aResult.SetResult( conErr, KDescription );

    		}

    	else

    		{

    		aResult.SetResult( disconErr, KDescription );

    		}

    	}

    __UHEAP_MARKEND;

    // Case was executed

    return err;

    }

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

// CAccMonitoringTestModule::TestHasAccessoryCapa

// In this test a wired headset is connected and then the information is fetched

// from the API. 

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

//

TInt CAccMonitoringTestModule::TestHasAccessoryCapaL( 

    TTestResult& aResult )

    {

    __UHEAP_MARK;

    TInt amount;

    TInt err(-999);

	CConnectionEmulator* con = CConnectionEmulator::NewL();

	CleanupStack::PushL( con );

	TBool sync( ETrue );

	TRAPD( conErr, con->ConnectAccessoryL( CConnectionEmulator::EWiredHeadSetCon, sync ) );

	COM_TRACE_1( "[AccFw:AccMon] CAccMonitoringTestModule::TestHasAccessoryCapaL - conErr = %d", conErr );

	if(conErr == KErrNone)

	    {

		RConnectedAccessories array;

		CleanupClosePushL( array );

		// Create an instance of the api and get the connected accessories

		CAccMonitor* api = CAccMonitor::NewL();

    	CleanupStack::PushL( api );    

		COM_TRACE_1( "[AccFw:AccMon] CAccMonitoringTestModule::TestHasAccessoryCapaL before - err = %d", err );

	    err = GetConnectedAccessoriesL(api, array, amount);

	    CleanupStack::PopAndDestroy( api );

	    if( array.Count() == 0 )

	        return KErrGeneral;

	    if(err == KErrNone)

	        {

	        COM_TRACE_( "[AccFw:AccMon] CAccMonitoringTestModule::TestHasAccessoryCapaL - Inside if(err == KErrNone)" );

	        // Get the information about the accessory

	        CAccMonitorInfo* info = CAccMonitorInfo::NewL( array[ 0 ] );

	        COM_TRACE_( "[AccFw:AccMon] CAccMonitoringTestModule::TestHasAccessoryCapaL - CAccMonitorInfo object created using array index 0" );

	        CleanupStack::PushL( info );

	        TBool result( EFalse );

	        // Use Exists inline function to check if the capability existed

	        result = info->Exists( KAccMonStereoAudio );

	        COM_TRACE_1( "[AccFw:AccMon] CAccMonitoringTestModule::TestHasAccessoryCapaL after - result = %d", result );

	        /**

	        * Check that accessories were fetched correctly and that it had the

	        * capability.

	        */

	        if( result || ( err != KErrNone ) )

	            {

	            _LIT( KDescription, "Accessory has that capability" );