/*

* Copyright (c) 2002-2009 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:  Connection Handler

*

*/

// INCLUDE FILES

#include "AccSrvConnectionHandler.h"

#include "AccSrvConnectionController.h" //MAccSrvConnectionControllerObserver

#include "AccPolSubblockNameArrayAccessor.h"

#include "AccPolAccessoryPolicy.h"

#include "AccSrvASYProxyHandler.h"

#include "AccSrvServerModel.h"

#include "AccPolGenericIDAccessor.h"

#include "AccPolicyDB.h"

#include "acc_debug.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TUid KAccFwUiDialogNotifierUid = { 0x10205062 };

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CAccSrvConnectionHandler::CAccSrvConnectionHandler

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

//

CAccSrvConnectionHandler::CAccSrvConnectionHandler(

    MAccSrvConnectionControllerObserver* aCallback,

    CAccSrvServerModel * aModel,

    CAccPolAccessoryPolicy* aPolicy )

    : CAccSrvHandlerBase (aCallback),

      iPolicy( aPolicy ),

      iModel( aModel),

      iReplyValue(0),

      iReplyPck( iReplyValue)

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::CAccSrvConnectionHandler()" );

    }

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

// CAccSrvConnectionHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAccSrvConnectionHandler::ConstructL()

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::ConstructL()" );

    }

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

// CAccSrvConnectionHandler::NewL

// Two-phased constructor.

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

//

CAccSrvConnectionHandler* CAccSrvConnectionHandler::NewL( 

    MAccSrvConnectionControllerObserver* aCallback,

	CAccSrvServerModel* aModel,

    CAccPolAccessoryPolicy* aPolicy )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::NewL()" );

    CAccSrvConnectionHandler* self = new( ELeave ) CAccSrvConnectionHandler( 

                                                        aCallback, aModel, aPolicy );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::NewL - return self" );

    return self;

    }

// Destructor

CAccSrvConnectionHandler::~CAccSrvConnectionHandler()

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::~CAccSrvConnectionHandler()" );

	//closes notfier connection

    iNotifier.Close();

    iRequestDataArray.Close();

    }

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

// CAccSrvConnectionHandler::RunL

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

//

void CAccSrvConnectionHandler::RunL()

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::RunL()" );

	switch ( iState )

	    {	

		/*

		Get response from the user (the notifier completes asyncronous command). Send

		accessory update command to ASY. 

		*/

		case EGetSelectionFromUser:

	    	{

		    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::RunL() - Get selection from user" );

			if ( iReplyValue )

			    {

			    COM_TRACE_1( "[AccFW:AccServer] CAccSrvConnectionHandler::RunL() - User selection %d", iReplyValue );

				//update generic id

				iPolicy->UpdateGenericIDL( iGenericID, iReplyValue);

				TASYCommandParamRecord asyCommandParamRecord;

    		    asyCommandParamRecord.iCmdValue   = 0;//Not used in update command

        		asyCommandParamRecord.iGenericID  = iGenericID;		

			    //Send request to ASY Proxy Handler

			    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::RunL() - Send update request");

			    TInt trId = iCallback->HandleASYCommsL( ECmdAccessoryUpdated,

        		                               		asyCommandParamRecord );

	    		//Stored request data is used when response is received from ASY

		    	//(i.e. HandleValueMessageL)

    			StoreRequestData( asyCommandParamRecord.iNameRecord, trId, ETrue );

	    		//Store this object to queue to be able to receive response from ASY

    			iCallback->RegisterControlMessageL( ESetValue, this );

    			//closes notfier connection

                iNotifier.Close();

			    }

			else

			    {

                // If this is KErrCancel, cancel is already done. Handle only if user has cancelled the dialog

                if ( KErrNone == iStatus.Int() )

                    {

                    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::RunL() - User cancel");

    	      	    iCallback->ConnectionHandlingCancel( this);	

                    }

			    }

	    	}

            break;

		case EInitializeConnection:

		    {

		    if( iCallback->ServerModelHandle().ASYsLoadCompleted() )

	            {

   	        	if ( iConnectionUpdate )

   	        	    {

   	        		//get new capabilities to use

				    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::RunL() - Connection update, set new capabilities");

   	        		iModel->CapabilityStorage().UseUpdatedGenericIDL( iGenericID);

   	        	    }

    	    	if ( InitializeCriticalCapsL() )

            	    {	

	            	//ASY query started

    	    	    }

        		else

    	            {

    	        	if ( iConnectionUpdate )

    	        	    {

	    	        	//No critical caps, continue connection handling

	    	        	TAccPolGenericID oldGenericId; 

	    	        	iModel->FindWithUniqueIDL(  iGenericID.UniqueID(), oldGenericId);

    		        	iCallback->HandleConnectionUpdateValidationL( 

                            iGenericID, oldGenericId, this, KErrNone );    	        		

    	        	    }

    	        	else

    	        	    {

	    	        	//No critical caps, continue connection handling

    		        	iCallback->HandleConnectValidationL( iGenericID, this, KErrNone );

	   	        	    }

	                }

	    	    }

	    	else

        	    {

	    	    //ASY is not ready yet, wait for an another RunL-loop

    	    	CAccSrvHandlerBase::IssueRequest();

        	    }			

		    }

		    break;

		case EWaitForUINotifier:

		    {

            // If cancelled, do not show dialog

            if ( KErrCancel != iStatus.Int() )

                {

                COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::RunL() - Change in boot state, try again open selection dialog" );

			    OpenSelectionDialogL();			

		        }

			}

		    break;

		default:

            TRACE_ASSERT_ALWAYS;

            break;

	    }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::RunL - return void" );

    }

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

// CAccSrvConnectionHandler::StartConnectionHandling

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

//

void CAccSrvConnectionHandler::StartConnectionHandlingL( 

    TAccPolGenericID& aGenericID, 

    TBool aEvaluateConnectionRules, 

    TBool aUpdatedConnection )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::StartConnectionHandling()" );

    iGenericID = aGenericID;

    iConnectionUpdate = aUpdatedConnection;

    //evaluate connection rules

    if ( aEvaluateConnectionRules )

        {

  		COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::StartConnectionHandling() - Evaluate connection rules" );

        }

    else

        {

  		COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::StartConnectionHandling() - No connection rules" );

        }

    // Atleas one Asynchronous request is made for ourselves,

    // clients ConnectAccessory asynchronous request will be completed

    // during it.

    if ( iState == EInitializeConnection )

        {

 	    CAccSrvHandlerBase::IssueRequest();

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::StartConnectionHandling- return void" );

    }

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

// CAccSrvConnectionHandler::OpenSelectionDialogL

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

//

void CAccSrvConnectionHandler::OpenSelectionDialogL()

    {

	COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::OpenSelectionDialogL() - start" );

	if ( !iModel->IdleDetected() )	

	    {

		COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::OpenSelectionDialogL() - Idle is not detected" );

		//boot is ongoing, wait for that ui notifier is ready	

		iState = EWaitForUINotifier;

		//wait for idle

		Cancel();

		iStatus = KRequestPending;

		iModel->WaitForIdle( &iStatus );

		SetActive();

	    }

	else

	    {

		COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::OpenSelectionDialogL() - Boot ok, connect notifier" );

		iState = EGetSelectionFromUser;

   		//selection bit mask package

	    TPckg<TUint32> selectionBitmaskPackage( iSelectionListBitmask );

		//activate active object

		Cancel();

		iStatus = KRequestPending;

		//open ui		

		COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::OpenSelectionDialogL() - Open selection dialog" );

        User::LeaveIfError( iNotifier.Connect() );

		iNotifier.StartNotifierAndGetResponse( 

                        iStatus, 

                        KAccFwUiDialogNotifierUid, 

                        selectionBitmaskPackage, 

                        iReplyPck);		

		SetActive();

	    }

	COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::OpenSelectionDialogL() - end" );

    }

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

// CAccSrvConnectionHandler::OpenSelectionDialogL

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

//

void CAccSrvConnectionHandler::SetupSelectionDialogL( TUint32 aSelectionListBitmask )

    {

	COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::SetupSelectionDialogL() - start" );

	iSelectionListBitmask = aSelectionListBitmask;		    

	//open dialog	

	OpenSelectionDialogL();

	COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::SetupSelectionDialogL() - end" );	

    }

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

// CAccSrvConnectionHandler::UniqueIDForConnectionHandler

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

//

TInt CAccSrvConnectionHandler::UniqueIDForConnectionHandler()

    {

	return iGenericID.UniqueID();

    }

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

// CAccSrvConnectionHandler::CancelConnectionHandling

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

//

void CAccSrvConnectionHandler::CancelConnectionHandling() 

    {

	COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::CancelConnectionHandling() - start" );

    if ( iNotifier.Handle() )

        {

        // If notifier exists, it must be cancelled

        iNotifier.CancelNotifier( KAccFwUiDialogNotifierUid );

        iNotifier.Close();

        // No need to cancel notifier request, cancel comes from notifier

        }

    else if ( IsActive() )

        {

        if ( EWaitForUINotifier == iState )

            {

            // Internal request, cancel in different way

            iModel->CancelWaitForIdle();

            }

        else

            {

            Cancel();   

            }

        }

	// remove this from NotificationQueue

    iCallback->CancelControlMessage( ESetValue, this );

	COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::CancelConnectionHandling() - end" );

    }

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

// CAccSrvConnectionHandler::ResetHandler

// Resets member variables and is free to handle next connection

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

//

void CAccSrvConnectionHandler::ResetHandler()

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::ResetHandler() - start" );

    // Reset member variables related to connection

    iSelectionListBitmask = 0;

    iReplyValue = 0;

    iState = EGetSelectionFromUser;

    iRequestDataArray.Reset();

    // Reset generic id. This also indicates that this hander has no connection

    TAccPolGenericID temp;

    iGenericID = temp;

    // No need to reset iPolicy, iModel or iGenericID

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::ResetHandler() - end" );

    }

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

// CAccSrvConnectionHandler::IsFree

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

//

TBool CAccSrvConnectionHandler::IsFree()

    {

    COM_TRACE_1( "[AccFW:AccServer] CAccSrvConnectionHandler::IsFree() - UniqueID(%i)", iGenericID.UniqueID() );

    return ( KErrNotFound == iGenericID.UniqueID() );

    }

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

// CAccSrvConnectionHandler::InitializeCriticalCapsL

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

//

TBool CAccSrvConnectionHandler::InitializeCriticalCapsL()

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionHandler::InitializeCriticalCapsL()" );

    TBool                    ASYqueryStarted( EFalse );

    TAccPolNameRecord        nameRecord;

    TUint32					 name( 0 );

    TASYCommandParamRecord   asyCommandParamRecord;

    CAccPolSubblockNameArray* criticalCapabilities = CAccPolSubblockNameArray::NewL();

    CleanupStack::PushL( criticalCapabilities );

    //After this query, criticalCapabilities contains all critical capabilities from iGenericID

    iPolicy->ResolveCriticalCapabilitiesL( iGenericID, *criticalCapabilities );

    TInt nameCount( TAccPolSubblockNameArrayAccessor::GetCount( *criticalCapabilities ) );

    for ( TInt i( 0 ) ; i<nameCount ; ++i )

        {

        TAccPolSubblockNameArrayAccessor::GetName( *criticalCapabilities,

                                                    i,

                                                    name );

  	    nameRecord.SetName( name );

        asyCommandParamRecord.iNameRecord = nameRecord;

        asyCommandParamRecord.iCmdValue   = 0;//Not used in Getters

        asyCommandParamRecord.iGenericID  = iGenericID;

		    CCapValue* capValue = iModel->CapabilityStorage().GetCapability( iGenericID, name );

		    if ( !capValue)

		        {

			      User::Leave( KErrArgument );

		        }

		    if ( capValue->Type() == EAPVBool || 

             capValue->Type() == EAPVUInt || 

             capValue->Type() == EAPVInt )

		        {

			      TInt32 value( 0 );

			      TInt err( capValue->ValueInt( value ) );

			      if ( value == KErrUnknown && err == KErrNone )

			          {

    		        StartASYCommandHandlingL( capValue->Type(), asyCommandParamRecord );

		            ASYqueryStarted = ETrue;

			          }

		        }

		    else