// Copyright (c) 2005-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:

//

// INCLUDE FILES

#include <e32std.h>

#include <bt_sock.h>

#include <btdevice.h>

#include "BTGPSPanic.h"

#include "BTGPSConnectManager.h"

#include "BTGPSSettingManager.h"

#include "BTGPSHandlerFactory.h"

#include "BTGPSDeviceManager.h"

#include "BTGPSMessageSender.h"

#include "BTGPSMessageReceiver.h"

#include "BTGPSPanic.h"

#include "BTGPSLogging.h"

#include "btgpsdevicelistmanager.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

//Process state enumeration

enum THandlerProcessState

    {

    EExitSuccess = -1,

    EExitFailed = -2,  //Connection failed, device is error

    EExitDisconnected = -3 //Connection can't be made, device is disconnected

    };

//There are two different connecting state machines 

#ifdef SYMBIAN_LOCATION_BTGPSCONFIG

const struct THandlerProcessItem KConnectingProcess[] = 

    {

        {EGetNextDevice, 	 	1,             7},           //0

        {ECheckDevicePairing,	2,			   3},			 //1

        {ESocketHandler,     	EExitSuccess,  0}, 		  	 //2

        {ESdpHandler,        	4,             0},           //3

        {EPairingHandler,    	6,             5},           //4

        {ESocketHandler,     	6,             0},           //5

        {EInitHandler,      	EExitSuccess,  0},           //6

        {EDeviceSelector,   	8,             EExitFailed}, //7

        {ESdpHandler,        	9,             7},           //8

        {EPairingHandler,    	11,            10},          //9

        {ESocketHandler,     	11,            7},           //10

        {EInitHandler,       	EExitSuccess,  7},           //11

    };

#else

//This struct defines the decision tree of the connection process

const struct THandlerProcessItem KConnectingProcess[] = 

    {

        {EDeviceInfoHandler, 1,             2},           //0

        {ESocketHandler,     EExitSuccess,  2}, 		  //1

        {EDeviceSelector,    3,             EExitFailed}, //2

        {ESdpHandler,        4,             2},           //3

        {EPairingHandler,    6,             5},           //4

        {ESocketHandler,     6,             2},           //5

        {EInitHandler,       EExitSuccess,  2},           //6

    };

//Reconnecting if socket error

const struct THandlerProcessItem KErrorRecoveryProcess[]=

    {

        {ESocketHandler, EExitSuccess, EExitDisconnected}

    };

#endif

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CBTGPSConnectManager::NewL

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

CBTGPSConnectManager* CBTGPSConnectManager::NewL(

        CBTGPSSettingManager& aSettingManager,

        CBTGPSDeviceManager& aDeviceManager,

        CBTGPSConstantsManager& aConstantsManager,

        CBTGPSDeviceListManager& aDeviceListManager)

    {

    CBTGPSConnectManager* self = new (ELeave) CBTGPSConnectManager(

        aSettingManager,

        aDeviceManager,

        aConstantsManager,

        aDeviceListManager);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CBTGPSConnectManager::~CBTGPSConnectManager

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

CBTGPSConnectManager::~CBTGPSConnectManager()

    {

    delete iMessageReceiver;

    delete iMessageSender;

    delete iActiveHandler;

    if(iIdle!=NULL)

        {

        iIdle->Cancel();

        delete iIdle;

        }

    //Close socket connection

    iSocket.Close();

    iSocketServ.Close();

    }

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

// CBTGPSConnectManager::ConstructL

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

void CBTGPSConnectManager::ConstructL()

    {

    iMessageSender = CBTGPSMessageSender::NewL(iSocket, iDeviceManager);

    iMessageReceiver = CBTGPSMessageReceiver::NewL(iSocket, iDeviceManager);

    iIdle = CIdle::NewL(CActive::EPriorityStandard);

    }

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

// CBTGPSConnectManager::CBTGPSConnectManager

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

// might leave.

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

CBTGPSConnectManager::CBTGPSConnectManager(

        CBTGPSSettingManager& aSettingManager,

        CBTGPSDeviceManager& aDeviceManager,

        CBTGPSConstantsManager& aConstantsManager,

        CBTGPSDeviceListManager& aDeviceListManager)

    :iSettingManager(aSettingManager),

     iDeviceManager(aDeviceManager),

     iConstantsManager(aConstantsManager),

     iDeviceListManager(aDeviceListManager)

    {

    }

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

// CBTGPSConnectManager::Connecting

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

TInt CBTGPSConnectManager::Connecting()

    {

    TRACESTRING("CBTGPSConnectManager::ConnectingL start...")

    //Get device connect status

    TBTDeviceConnectStatus connectStatus = 

        iDeviceManager.DeviceConnectStatus();

    switch (connectStatus)

        {

        case EBTDeviceDisconnected:

            //start to connect to BT device

            break;

        case EBTDeviceConnecting:

        case EBTDeviceConnected:

            //do nothing if it's in connecting or connected status

            return KErrNone;

        case EBTDeviceConnectError:

            //If device error then fail the request with KErrQualityLoss

            return KErrCouldNotConnect;

        default:

            //should never hapen

            Panic(EPanicInvalidCase);

            break;

        }

    //Start to connect to BT Device

    StartConnectDevice();

    TRACESTRING("CBTGPSConnectManager::ConnectingL end")

    return KErrNone;

    }

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

// CBTGPSConnectManager::Reconnecting

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

void CBTGPSConnectManager::Reconnecting()

    {

    //Get device connect status

    TBTDeviceConnectStatus connectStatus = 

        iDeviceManager.DeviceConnectStatus();

    switch (connectStatus)

        {

        case EBTDeviceDisconnected:

        case EBTDeviceConnectError:

            //start to connect to BT device

            break;

        case EBTDeviceConnecting:

        case EBTDeviceConnected:

            //do nothing if it's in connecting or connected status

            return;

        default:

            //should never hapen

            Panic(EPanicInvalidCase);

            break;

        }

    //Start to connect to BT Device

    StartConnectDevice();

    }

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

// CBTGPSConnectManager::StartConnectDevice

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

void CBTGPSConnectManager::StartConnectDevice()

    {

    //This function should be return imediately. Thus real functoinalities

    //are moved to idle callback function

    //Set connection status

    iDeviceManager.SetBTDeviceConnectStatus(EBTDeviceConnecting);

    if(!iIdle->IsActive())

        {

        iIdle->Start(TCallBack(StaticIdleCallback, this));

        }

    }

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

// CBTGPSConnectManager::StartConnectIdle

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

void CBTGPSConnectManager::StartConnectIdle()

    {

    TRAPD(err, StartConnectIdleL());

    if(err!=KErrNone)

        {

        iDeviceManager.SetBTDeviceConnectStatus(EBTDeviceConnectError, err);

        }

    }

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

// CBTGPSConnectManager::StartConnectIdleL

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

void CBTGPSConnectManager::StartConnectIdleL()

    {

    //Cancel idle object

    iIdle->Cancel();

#ifdef SYMBIAN_LOCATION_BTGPSCONFIG

    //Reset the BT GPS device list

    iDeviceListManager.RefreshDeviceList();

    //Always start the full connecting process even when attempting to reconnect.

    // This will cause the PSY to attempt to reconnect to the device it was just connected

    // to (as it will be at the top of the list).  Failure to reconnect to this device once

    // will cause the PSY to continue attempting to connect to the remaining devices in the list.

    StartConnectingProcessL(KConnectingProcess);

#else

    if(iDeviceManager.IsGpsConnected())

        {

        //Connection error case. Device has already connected, but

        //might some error happens in socket connection.

        //Set device disconnected

        DisconnectBtDevice();

        StartConnectingProcessL(KErrorRecoveryProcess);

        }

    else

        {

        //start connecting process

        StartConnectingProcessL(KConnectingProcess);

        }

#endif

    }

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

// CBTGPSConnectManager::StaticIdleCallback

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

TInt CBTGPSConnectManager::StaticIdleCallback(TAny* aAny)

    {

    reinterpret_cast<CBTGPSConnectManager*>(aAny)->StartConnectIdle();

    return KErrNone; //shall not be called again

    }

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

// CBTGPSConnectManager::CancelConnecting

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

void CBTGPSConnectManager::CancelConnecting()

    {

    //Stop idle

    iIdle->Cancel();

    //Stop current handler

    delete iActiveHandler;

    iActiveHandler = NULL;

    //Stop current process

    iActiveProcess = NULL;

    DisconnectBtDevice();

    }

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

// CBTGPSConnectManager::DisconnectBtDevice

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

void CBTGPSConnectManager::DisconnectBtDevice()

    {

    TRACESTRING("CBTGPSConnectManager::DisconnectBtDevice start...")

    TInt connectStatus = iDeviceManager.DeviceConnectStatus();

    if(connectStatus==EBTDeviceConnected ||

        connectStatus==EBTDeviceConnectError

        && iSocket.SubSessionHandle()!=0)

        {

        //Disconnect from GPS

        //Update device connection status

        iDeviceManager.SetBTDeviceConnectStatus(

            EBTDeviceDisconnected,

            KErrCancel);

        //Close socket connection

        iSocket.Close();

        }

    }

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

// CBTGPSConnectManager::StartConnectingProcessL

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

void CBTGPSConnectManager::StartConnectingProcessL(const THandlerProcessItem* aProcess)

    {

    //Just construct the first item in the process

    if(iActiveHandler!=NULL)

        {

        delete iActiveHandler;

        iActiveHandler = NULL;

        }

    iActiveProcess = aProcess;

    TBTGPSHandlerFactory handlerFactory(

        *this);

    iCurrentNode = 0;

    iActiveHandler = handlerFactory.ConstructHandlerL(aProcess->iHandlerId);

    }

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

// CBTGPSConnectManager::DeviceManager

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

CBTGPSDeviceManager& CBTGPSConnectManager::DeviceManager() const

    {

    return iDeviceManager;

    }

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

// CBTGPSConnectManager::ConstantsManager

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

CBTGPSConstantsManager& CBTGPSConnectManager::ConstantsManager() const

    {

    return iConstantsManager;

    }

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

// CBTGPSSettingManager::SettingManager

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

CBTGPSSettingManager& CBTGPSConnectManager::SettingManager() const

    {

    return iSettingManager;

    }

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

// CBTGPSSettingManager::DeviceListManager

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

CBTGPSDeviceListManager& CBTGPSConnectManager::DeviceListManager() const

	{

	return iDeviceListManager;

	}

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

// CBTGPSConnectManager::GetSocket

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

void CBTGPSConnectManager::GetSocket(

            RSocketServ*& aSocketServ,

            RSocket*& aSocket)

    {

    aSocketServ = &iSocketServ;

    aSocket = &iSocket;

    }

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

// CBTGPSConnectManager::HandlerComplete

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

void CBTGPSConnectManager::HandlerComplete(TInt aId, TInt aErr)

    {

    TRACESTRING("CBTGPSConnectManager::HandlerComplete start..")

    TRACESTRING2("node = %d", iCurrentNode)

    TRACESTRING2("err= %d", aErr)

    //Find node in process decision tree

    const THandlerProcessItem* item = iActiveProcess+iCurrentNode;

    //Panic in debug if process defination is incorrect

    __ASSERT_DEBUG(item!=NULL, Panic(EPanicProcessDefination));

    //If socket handler succeeds, then set device as connected

    if( ( aId == ESocketHandler || aId == EPairingHandler ) && aErr==KErrNone)

        {

        iDeviceManager.SetBTDeviceConnectStatus(

            EBTDeviceConnected,

            aErr);

        }

    iLastError = aErr;

    if(aErr==KErrNone)

        {

        iCurrentNode = item->iSuccessNodeIndex;

        }

    else

        {

        iCurrentNode = item->iFailedNodeIndex;

        }

    StartNextHandler();

    TRACESTRING("CBTGPSConnectManager::HandlerComplete end")

    }

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

// CBTGPSConnectManager::

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

void CBTGPSConnectManager::StartNextHandler()

    {

    //Delete current handler

    if(iActiveHandler != NULL)

        {

        delete iActiveHandler;

        iActiveHandler = NULL;

        }

    switch(iCurrentNode)

        {

        case EExitFailed:

        case EExitSuccess:

        case EExitDisconnected:

            ConnectComplete(iCurrentNode);

            break;

        default:

            {

            //Start next item

            const THandlerProcessItem* item = iActiveProcess+iCurrentNode;

            TBTGPSHandlerFactory handlerFactory(*this);

            TRAPD(handlerErr, 

                iActiveHandler = handlerFactory.ConstructHandlerL(

                    item->iHandlerId));

            if(handlerErr != KErrNone)

                {

                iLastError = handlerErr;

                //handler construction failed, start next handler

                iCurrentNode = item->iFailedNodeIndex;

                StartNextHandler();

                }

            }

        }

    }

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

// CBTGPSConnectManager::ConnectComplete

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

void CBTGPSConnectManager::ConnectComplete(TInt aErr)

    {

    //Clear active process

    iActiveProcess = NULL;

    switch( aErr )

        {

        case EExitSuccess:

            //Do nothing here. the device is connected

            break;

        case EExitDisconnected:

            //Set device as disconected. Next location

            //request will trigger the connecting procedure.

            iDeviceManager.SetBTDeviceConnectStatus(

                EBTDeviceDisconnected,

                iLastError);

            break;

        case EExitFailed:

        default:

            //Set device as connect error. Next new 

            //subsession will trigger the connecting procedure.

            iDeviceManager.SetBTDeviceConnectStatus(

                EBTDeviceConnectError,

                iLastError);

            break;

        }

    }

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

// CBTGPSConnectManager::AddMessageListenerL

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

void CBTGPSConnectManager::AddMessageListenerL(MBTGPSMessageListener& aListener)

    {

    iMessageReceiver->AddMessageListenerL(aListener);

    }

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

// CBTGPSConnectManager::RemoveMessageListener