/*

* 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 Controller

*

*/

// INCLUDE FILES

#include "AccSrvConnectionController.h"

#include "AccPolAccessoryPolicy.h"

#include "AccSrvServerModel.h"

#include "AccSrvNotificationQueue.h"

#include "AccSrvConnectionStatusHandler.h"

#include "AccSrvModeHandler.h"

#include "AccPolGenericIDArrayAccessor.h"

#include "acc_debug.h"

#include "AccSrvASYProxyHandler.h"

#include "AccPolGenericIDAccessor.h"

#include "AccSrvSettingsHandler.h"

#include "AccPolSubblockNameArrayAccessor.h"

#include <AccConfigFileParser.h>

#include <s32mem.h>

#include "AccSrvWiredConnectionPublisher.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TUid KAccFwUiNoteNotifierUid = { 0x10205061 };

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CAccSrvConnectionController::CAccSrvConnectionController

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAccSrvConnectionController::CAccSrvConnectionController()

    : CActive( EPriorityStandard ),

      iPolicy( NULL ),

      iServerModel( NULL ),

      iNotificationQueue( NULL ),

      iConnectionStatusHandler( NULL ),

      iModeHandler( NULL ),

      iASYProxyHandler( NULL ),

      iShowNotes( EFalse ),

      iWiredConnPublisher( NULL ),

      iReplyPck( iReplyValue)

    {

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

    CActiveScheduler::Add( this );//Add the active object to the active scheduler

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::CAccSrvConnectionController - return" );

    }

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

// CAccSrvConnectionController::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAccSrvConnectionController::ConstructL( CAccSrvServerModel* aServerModel )

    {

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

    iServerModel             = aServerModel;

    iPolicy                  = CAccPolAccessoryPolicy::NewL( &iServerModel->CapabilityStorage());

    iNotificationQueue       = CAccSrvNotificationQueue::NewL();

    iConnectionStatusHandler = CAccSrvConnectionStatusHandler::NewL( this );

    iModeHandler             = CAccSrvModeHandler::NewL( this );

    iASYProxyHandler         = CAccSrvASYProxyHandler::NewL( this );

    iSettingsHandler         = CAccSrvSettingsHandler::NewL( this, *aServerModel );

    iWiredConnPublisher      = CAccSrvWiredConnectionPublisher::NewL();

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::ConstructL - return void" );

    }

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

// CAccSrvConnectionController::NewL

// Two-phased constructor.

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

//

CAccSrvConnectionController* CAccSrvConnectionController::NewL(

    CAccSrvServerModel* aServerModel )

    {

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

    CAccSrvConnectionController* self = new( ELeave ) CAccSrvConnectionController;

    CleanupStack::PushL( self );

    self->ConstructL( aServerModel );

    CleanupStack::Pop( self );

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

    return self;

    }

// Destructor

CAccSrvConnectionController::~CAccSrvConnectionController()

    {

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

    if( NULL != iPolicy )

        {

        delete iPolicy;

        }

    if( NULL != iNotificationQueue )

        {

        delete iNotificationQueue;

        }

    if( NULL != iConnectionStatusHandler )

        {

        delete iConnectionStatusHandler;

        }

    if( NULL != iModeHandler )

        {

        delete iModeHandler;

        }

    if( NULL != iASYProxyHandler )

        {

        delete iASYProxyHandler;

        }

    if( NULL != iSettingsHandler )

        {

        delete iSettingsHandler;

        }

    delete iWiredConnPublisher;

    // Handlers must be deleted after iPolicy and iASYProxyHandler

    // (used from handlers).

    iConnectionHandler.ResetAndDestroy();

    if ( iNotifier.Handle() )

        {

        iNotifier.Close();

        }

    Cancel();

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::~CAccSrvConnectionController - return" );

    }

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

// CAccSrvConnectionController::ServerModel

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

//

CAccSrvServerModel& CAccSrvConnectionController::ServerModel() const

    {

    return *iServerModel;

    }

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

// CAccSrvConnectionController::NotificationQueue

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

//

CAccSrvNotificationQueue& CAccSrvConnectionController::NotificationQueue() const

    {

    return *iNotificationQueue;

    }

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

// CAccSrvConnectionController::ASYProxyHandler

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

//

CAccSrvASYProxyHandler& CAccSrvConnectionController::ASYProxyHandler() const

    {

    return *iASYProxyHandler;

    }

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

// CAccSrvConnectionController::SettingsHandler

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

//

CAccSrvSettingsHandler& CAccSrvConnectionController::SettingsHandler() const

    {

    return *iSettingsHandler;

    }

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

// CAccSrvConnectionController::Policy

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

//

CAccPolAccessoryPolicy& CAccSrvConnectionController::Policy() const

    {

    return *iPolicy;

    }

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

// CAccSrvConnectionController::HandleConnectL

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

//

void CAccSrvConnectionController::HandleConnectL( TAccPolGenericID& aGenericID,

                                                  TUint aCallerThreadID,

                                                  TBool aEvaluateConnectionRules,

                                                  TBool aUpdateConnection )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::HandleConnectL()" );

	if ( aUpdateConnection )

	    {

	    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::HandleConnectL() Update connection" );

		//check is there connection handling ongoing for unique id

		TInt index( KErrNotFound );

		for ( TInt i(0); i < iConnectionHandler.Count(); i++ )

	    	{

			if ( aGenericID.UniqueID() == 

                 iConnectionHandler.operator[]( i )->UniqueIDForConnectionHandler() )

			    {

				index = i;

				break;

			    }

	    	}

		//cancel current connection handling and reset connection handler

		if ( KErrNotFound == index)

		    {

            //Create a new connection handler for this connection and start the handling

            CAccSrvConnectionHandler* connectionHandler = CAccSrvConnectionHandler::NewL( this, iServerModel, iPolicy );

            CleanupStack::PushL( connectionHandler );

            iConnectionHandler.InsertL( connectionHandler, 0 );

            CleanupStack::Pop( connectionHandler );

            index = 0;

            }

        else

            {

            COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::HandleConnectL() Connection handling ongoing - delete current connection handler" );

			iConnectionHandler.operator[]( index )->CancelConnectionHandling();

            iConnectionHandler.operator[]( index )->ResetHandler();

   		    }

	    // Restart connection handling

    	iConnectionHandler.operator[]( index )->StartConnectionHandlingL( 

                                                    aGenericID,

                                                    aEvaluateConnectionRules, 

                                                    iServerModel->IsConnectedOrDetected( 

                                                        aGenericID ) );

    	}

	else

    	{

	    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::HandleConnectL() New connection" );

	    // Store ThreadId for ASY handling

	    iServerModel->StoreASYThreadID( aCallerThreadID, aGenericID.UniqueID() );

	    iServerModel->AddPhysicalConnectionL( aGenericID );		

	    iWiredConnPublisher->HandleConnectL( aGenericID );

        // Search for free connection handlers

        TInt index( KErrNotFound);

		for ( TInt i(0); i < iConnectionHandler.Count(); i++ )

		    {

			if ( iConnectionHandler.operator[]( i )->IsFree() )

			    {

				index = i;

				break;

			    }

		    }

        // Create new connection handler if available connection handler is not found

        if ( KErrNotFound == index )

            {

            COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::HandleConnectL - Available handler not found, creating new" );

            CAccSrvConnectionHandler* handler = CAccSrvConnectionHandler::NewL( 

                this, iServerModel, iPolicy );

            CleanupStack::PushL( handler );

            handler->StartConnectionHandlingL( aGenericID, aEvaluateConnectionRules, EFalse );

            iConnectionHandler.AppendL( handler );

            CleanupStack::Pop( handler );

            }

        else

            {

            // Available hander found, using that

            COM_TRACE_1( "[AccFW:AccServer] CAccSrvConnectionController::HandleConnectL - Available handler found at %i, using that", index );

            iConnectionHandler.operator[]( index )->StartConnectionHandlingL( 

                aGenericID, aEvaluateConnectionRules, EFalse );

            }	

    	}

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::HandleConnectL - return void" );

    }

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

// CAccSrvConnectionController::HandleConnectionUpdateValidationL

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

//

void CAccSrvConnectionController::HandleConnectionUpdateValidationL( 

    const TAccPolGenericID& aGenericID, 

	TAccPolGenericID& aOldGenericId,

	const CAccSrvConnectionHandler* aCaller,	

	TInt aError )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::HandleConnectionUpdateValidationL()" );

    TInt err ( KErrNone );

    TAccSrvConnection isValidConnection(EAccSrvConnect);

    TBool isConnected( iServerModel->IsConnected( aGenericID ) );

    if( KErrNone == aError )

        {   

        isValidConnection = iPolicy->IsValidConnectionL( aGenericID, err );

        }

    else

        {

        err = aError;

        isValidConnection = EAccSrvDeny;

        }

    if( iServerModel->FindAndRemoveCancelledConnectAccessory( aGenericID.UniqueID() ) )

        {

        //Connection of this accessory is cancelled.

        err = KErrCancel;

        isValidConnection = EAccSrvDeny;

        }

    switch( isValidConnection )

        {

        case EAccSrvDetect:

            {

            if( isConnected )

                {

                //accessory was connected, but now it is detected

 			    iServerModel->AddPhysicalConnectionL( aGenericID ); //Move GID from physical connection array

			    iServerModel->RemoveConnectionL( aGenericID, EFalse );            //to connection array

  		        // Complete all possible connection status related requests

        		iNotificationQueue->CompleteControlMessageL( EAccessoryConnectionStatusChanged,

                                                		     KErrNone,

	                                                    	 aGenericID.UniqueID() );

        		iNotificationQueue->CompleteControlMessageL( EAccessoryDisconnected,

                		                                     KErrNone,

                        		                             aOldGenericId.UniqueID() );

                }

            else

                {

                //Accessory remains in detected state.

                }

            }

            break;

        case EAccSrvConnect:

            {

            if( isConnected )

                {

                //update connection generic id array

                iServerModel->UpdateConnectionL( aGenericID);

 		        // Complete all possible connection status related requests

        		iNotificationQueue->CompleteControlMessageL( EAccessoryConnectionStatusChanged,

                                                		     KErrNone,

	                                                    	 aGenericID.UniqueID() );

        		iNotificationQueue->CompleteControlMessageL( EAccessoryDisconnected,

                		                                     KErrNone,

                        		                             aOldGenericId.UniqueID() );

    		    iNotificationQueue->CompleteControlMessageL( ENewAccessoryConnected,

                                        		             KErrNone,

                                		                     aGenericID.UniqueID() );

                }

            else

                {

                //accessory was detected, but now it is connected

			    iServerModel->RemovePhysicalConnection( aGenericID ); //Move GID from physical connection array

			    iServerModel->AddConnectionL( aGenericID );            //to connection array

 		        // Complete all possible connection status related requests

        		iNotificationQueue->CompleteControlMessageL( EAccessoryConnectionStatusChanged,

                                                		     KErrNone,

	                                                    	 aGenericID.UniqueID() );

    		    iNotificationQueue->CompleteControlMessageL( ENewAccessoryConnected,

                                        		             KErrNone,

                                		                     aGenericID.UniqueID() );

                }

            }

            break;

        case EAccSrvDeny:

            {

            iServerModel->RemovePhysicalConnection( aGenericID );

            iServerModel->RemoveASYThreadID( aGenericID.UniqueID() );//Remove ThreadID GID mapping

            iServerModel->CapabilityStorage().RemoveCapabilityList( aGenericID);

            }

            break;

        default:

            {

            TRACE_ASSERT_ALWAYS;//unhandled enum

            }

            break;

        }

    iNotificationQueue->CompleteControlMessageL( EConnectAccessory,

                                                 err,

                                                 aGenericID.UniqueID() );

    //"This" connection handler has done its job

    TInt index( iConnectionHandler.Find( aCaller ) );

    if( KErrNotFound != index )

        {

        delete iConnectionHandler.operator[]( index );

        iConnectionHandler.Remove( index );

        }

    else

        {

        TRACE_ASSERT_ALWAYS; //iConnectionHandler array is not in sync

        }

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::HandleConnectionUpdateValidationL - return void" );

    }

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

// CAccSrvConnectionController::ConnectionHandlingCancel

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

//

void CAccSrvConnectionController::ConnectionHandlingCancel(

    const CAccSrvConnectionHandler* aCaller )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::ConnectionHandlingCancel - start" );

    //"This" connection handler has done its job

    TInt index( iConnectionHandler.Find( aCaller ) );

    if( KErrNotFound != index )

        {

        COM_TRACE_1( "[AccFW:AccServer] CAccSrvConnectionController::ConnectionHandlingCancel - Handler found at %i", index );

        iConnectionHandler.operator[]( index )->CancelConnectionHandling();

        iConnectionHandler.operator[]( index )->ResetHandler();

        }

    else

        {

        TRACE_ASSERT_ALWAYS; //iConnectionHandler array is not in sync

        }

	COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::ConnectionHandlingCancel - end" );

    }

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

// CAccSrvConnectionController::HandleConnectValidationL.

//

// During AccessoryConnection this is the phase where all critical capabilities

// are initialized and decision for connection acceptance can be done.

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

//

void CAccSrvConnectionController::HandleConnectValidationL(

    const TAccPolGenericID& aGenericID,

    const CAccSrvConnectionHandler* aCaller,

    TInt aError )

    {

    COM_TRACE_( "[AccFW:AccServer] CAccSrvConnectionController::HandleConnectValidationL()" );

    TInt err ( KErrNone );

    TAccSrvConnection isValidConnection( EAccSrvConnect );

    if( KErrNone == aError )

        {   

        isValidConnection = iPolicy->IsValidConnectionL( aGenericID, err );

        }

    else

        {

        err = aError;

        isValidConnection = EAccSrvDeny;

        }

    if( iServerModel->FindAndRemoveCancelledConnectAccessory( aGenericID.UniqueID() ) )

        {

        //Connection of this accessory is cancelled.

        err = KErrCancel;

        isValidConnection = EAccSrvDeny;

        }

    iNotificationQueue->CompleteControlMessageL( EConnectAccessory,

                                                 err,

                                                 aGenericID.UniqueID() );

    switch( isValidConnection )

        {

        case EAccSrvDetect:

            {

            // Accessory is detected but not connected.

            // Further changes to capabilities may change this

            // i.e. connection status changes from detected to connected.

            // Detected accessory is allready in physical connection table

            // (AddPhysicalConnectionL), so there is nothing to do here.

            }

            break;

        case EAccSrvConnect:

            {

            PromoteToConnectedL( aGenericID );

            }

            break;

        case EAccSrvDeny:

            {