/*

* Copyright (c) 2006-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:  Maintain a Bluetooth devices data model for paired devices view

*

*/

#include "btpairedmodel.h"

#include <btengutil.h>

#include "debug.h"

#include "btui.h"

const TInt KMaxCheckedConnections=20;

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

// CBTPairedModel::CBTPairedModel

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

//

CBTPairedModel::CBTPairedModel(MBTDeviceObserver* aObserver, TBTDeviceSortOrder* aOrder)

	: CBTDevModelBase(aObserver, aOrder)

    {

	TRACE_FUNC_ENTRY    

    TRACE_FUNC_EXIT	

    }

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

// CBTPairedModel::NewL

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

//

CBTPairedModel* CBTPairedModel::NewL(MBTDeviceObserver* aObserver, TBTDeviceSortOrder* aOrder )

    {

    CBTPairedModel* self = new (ELeave) CBTPairedModel(aObserver, aOrder);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;       

    }

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

// Destructor

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

//

CBTPairedModel::~CBTPairedModel()

    {

	TRACE_FUNC_ENTRY    

    delete iConnMan;

    delete iPairingDevice;

    delete iLinks;

    delete iBtEngSettings;

    iSocketServ.Close();    

    TRACE_FUNC_EXIT    

    }

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

// CBTPairedModel::ConstructL

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

//

void CBTPairedModel::ConstructL()

    {

	TRACE_FUNC_ENTRY

    // get all devices from btregistry to cache - local copy of CBTDeviceArray

    iDevMan = CBTEngDevMan::NewL(this);

    iConnMan = CBTEngConnMan::NewL(this);

    iSearchPattern.FindAll(); 

   	iRegistryObserver = CBTRegistryObserver::NewL(this, iSearchPattern);

	iRegistryObserver->Refresh();

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

	iLinks=CBluetoothPhysicalLinks::NewL(*this,iSocketServ);

	iBtEngSettings = CBTEngSettings::NewL(this);

    TRACE_FUNC_EXIT	

    }

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

// CBTPairedModel::IsAnyDeviceConnected

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

//

TBool CBTPairedModel::IsAnyDeviceConnected()

    {        

	TRACE_FUNC_ENTRY

	FlagPhysicallyConnectedDevices(iDeviceArray);

	for(TInt i = 0; i < iDeviceArray.Count(); i++)

		{

		if(iDeviceArray[i]->iStatus & (EStatusPhysicallyConnected|EStatusBtuiConnected))

			{

			TRACE_FUNC_EXIT				

			return ETrue;

			}        

		}

	TRACE_FUNC_EXIT				

    return EFalse;

    }

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

// CBTPairedModel::DoChangeDevice

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

TInt CBTPairedModel::DoChangeDeviceL(const TBTDevice& aDevice)

    {

    TRACE_FUNC_ENTRY

    TRACE_BDADDR(aDevice.iAddr)

   	// check that the device actually still exists

   	if(aDevice.iOperation != EOpPair )

   		{

   		User::LeaveIfError( GetIndexByAddress(aDevice.iAddr, aDevice.iIndex ) );	

   		}

    // disconnect device to be unpaired, or blocked

    if((aDevice.iOperation == EOpBlock || aDevice.iOperation == EOpUnpair ))

    	{    	

    	if( iState != EDisconnectBeforeOperationState)

    		{

    	}

    if(	aDevice.iOperation ==EOpPair)

    	{

    	DoPairDeviceL();

    	TRACE_FUNC_EXIT 

    	return KErrNone;    	

    	}

    TInt err = CBTDevModelBase::DoChangeDeviceL(aDevice);

    if (err != KErrNone)

        {      

        TBTDevAddr addr;

        if(aDevice.iAddr == KNullAddress )

        	{        	        	

        	if(aDevice.iIndex < 0 || aDevice.iIndex >= iDeviceArray.Count())

        		return KErrArgument;

        	else

        		addr=iDeviceArray[aDevice.iIndex]->iAddr;

        	}

        	else

        		addr=aDevice.iAddr;

        switch (aDevice.iOperation)

            {

            case EOpConnect:

            	{                    	   		            		               

                err = iConnMan->Connect(addr, aDevice.iDeviceClass);

                break;

            	}

            case EOpDisconnect:

            	{

            	iDisconnectDevice=new(ELeave) TBTDevice(aDevice);            		            		           	

				if (aDevice.iStatus & static_cast<TInt>(EStatusBtuiConnected ) )            	

					{

					err = iConnMan->Disconnect(addr, EBTDiscImmediate);	

					}

				else

					{

					err=iLinks->Disconnect(aDevice.iAddr);

					}

                break;

            	}

            default:

            	User::Leave(err);

                break;

            }

        }

    TRACE_FUNC_EXIT        

    return err;

    }

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

// CBTPairedModel::DoCancelChange

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

//    

void CBTPairedModel::DoCancelChangeL(const TBTDevice& aDevice)

    {

    TRACE_FUNC_ENTRY

	if(aDevice.iIndex >= iDeviceArray.Count())

        {

        TRACE_INFO((_L("index is %d, max expected is %d"), aDevice.iIndex, iDeviceArray.Count()));

        TRACE_FUNC_EXIT    

		return; 

        }

    // in case it was stopped

    iRegistryObserver->StartIfNotRunning();

    switch (aDevice.iOperation)

        {

        case EOpPair:

        	if( iState==EDeleteDeviceState || iState==EAddDeviceState )

        		{

        		iDevMan->Cancel();

        		}        		

        	else

        		{

        		iConnMan->CancelPairDevice();

        		}            	        	

            delete iPairingDevice;

            iPairingDevice=NULL;

            iState=EIdleState;

            iRegistryObserver->Refresh();

            break;

        case EOpConnect:

        	{	

            TBTDevAddr addr;

            if(aDevice.iIndex == KErrNotFound) 

            	{

            	addr=aDevice.iAddr;

            	}                

            else

            	{

            	addr=iDeviceArray[aDevice.iIndex]->iAddr;

            	}

            iConnMan->CancelConnect(addr);

            break;

        	}

        default:

            CBTDevModelBase::CancelChange(aDevice);

            return;

        }

    iRegistryObserver->StartIfNotRunning();

	if(iQueue.Count()>0)

		{

		delete iQueue[0];

		iQueue.Remove(0);		

		HandleQueue();

		}

    TRACE_FUNC_EXIT	       

    }

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

// CBTPairedModel::HandleNewDevice

//

// Adds the device if it is not banned

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

//

void CBTPairedModel::HandleNewDeviceL(const CBTDevice* aRegDevice,

        TNameEntry* aNameEntry)

    {

    TRACE_FUNC_ENTRY

    // It is needed to filter out blocked devices,

    // since otherwise blocked and paired devices would

    // be listed.

    if( ! aRegDevice->GlobalSecurity().Banned()     	

            && IsUserAwarePaired( aRegDevice->AsNamelessDevice() ) ) 

        {

        AddDeviceL(aRegDevice, aNameEntry, EOpNone);

        }

    TRACE_FUNC_EXIT		    

    }

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

// CBTPairedModel::CreateDevice

//

// This implementaion will add the connectable status from the superclass.

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

//

TBTDevice* CBTPairedModel::CreateDeviceL(const CBTDevice* aRegDevice,

        TNameEntry* aNameEntry)

    {

    TRACE_FUNC_ENTRY

    TBTDevice* device = CBTDevModelBase::CreateDeviceL(aRegDevice, aNameEntry);

    // add EStatusBtuiConnected status if the device has a profile connection

    TBTEngConnectionStatus connStatus;

    iConnMan->IsConnected(device->iAddr, connStatus);

    if(connStatus == EBTEngConnecting || connStatus == EBTEngConnected)

    	{

    	SetStatusFlags(device->iStatus,EStatusBtuiConnected);

    	}

    // add connectable status

    TBool connectable=EFalse;

    iConnMan->IsConnectable(aRegDevice->BDAddr(), aRegDevice->DeviceClass(), connectable );

    if( connectable) 

    	{

    	SetStatusFlags(device->iStatus, EStatusConnectable );

    	}

	TRACE_FUNC_EXIT 

    return device;

    }

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

// CBTPairedModel::ConnectComplete

// from MBTEngConnObserver

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

//

void CBTPairedModel::ConnectComplete(TBTDevAddr& aAddr, TInt aErr, RBTDevAddrArray* aConflicts)

    {

    TRACE_FUNC_ENTRY

    TRACE_INFO((_L("aErr=%d"), aErr))

    TInt index = GetIndexByAddress(aAddr);

    TBool requestIssuedFromPhone = EFalse;

    TBTDevice connectedDevice;

    // was the device connected from request by the ui

	if(iQueue.Count()>0 && iQueue[0]->iOperation==EOpConnect && 

	  iQueue[0]->iAddr == aAddr)

		{

		requestIssuedFromPhone = ETrue;

		if(index >=0) // is it from paired list

			{			

			connectedDevice=*iDeviceArray[index];

			connectedDevice.iOperation=EOpConnect;

			}

		else

			{

			connectedDevice=*iQueue[0];		

			}

    	}

    else

    	{

    	requestIssuedFromPhone = EFalse;

		if(index >=0) // is it from paired list

			{

			connectedDevice=*iDeviceArray[index];

			connectedDevice.iOperation=EOpConnect;

			}

		else

			{

	    	// it was not. Try to fill what can be filled.

			connectedDevice.iAddr=aAddr;

			connectedDevice.iIndex=KErrNotFound;

			connectedDevice.iOperation = EOpConnect;			

			}    	

    	}        

    if (aErr == KErrAlreadyExists )

        { 

        // gather the names of the conflicting devices.

        RBTDevNameArray nameArray;

        for (TInt i = 0; aConflicts!= NULL && i < aConflicts->Count(); i++)

            {

            //remove duplicates

            if(i>0&& (*aConflicts)[i]==(*aConflicts)[i-1])

            	{

            	continue;

            	}

            TInt di = GetIndexByAddress((*aConflicts)[i]);

            if(di >=0 )

            	{

            	nameArray.Append(&iDeviceArray[di]->iName);

            	}

            }

        // we will unset the connect status of the device if connection failed &

            // it is found in paired devices.

        if( index >= 0 )

            {

            // add EStatusBtuiConnected status if the device has a profile connection

            TBTEngConnectionStatus connStatus;

            iConnMan->IsConnected(connectedDevice.iAddr, connStatus);

            if (connStatus != EBTEngConnecting && connStatus != EBTEngConnected)

                {

                TRACE_INFO(_L("Unset EStatusBtuiConnected"))

                UnsetStatusFlags(iDeviceArray[index]->iStatus,EStatusBtuiConnected );

                }

            }

        if(iObserver)

            {

            //Show only phone issued request complete notes

            //Do not show notes for device issued request when BTUI is active

            if ( requestIssuedFromPhone ) 

                {

                iObserver->NotifyChangeDeviceComplete(aErr, connectedDevice, &nameArray);

                }

            SendRefreshIfNoError(aErr);

            }

        nameArray.Reset();

        }

    else 

        {

        if (aErr == KErrNone)

            {

            // we will set the connect status of the device

            // if it is found in paired devices.

            if( index >= 0 )

            	{

            	SetStatusFlags(iDeviceArray[index]->iStatus,EStatusBtuiConnected );

            	}

            }

        else        

            {

            // we will unset the connect status of the device if connection failed &

            // it is found in paired devices.

            if( index >= 0 )

                {                   

                // add EStatusBtuiConnected status if the device has a profile connection

                TBTEngConnectionStatus connStatus;

                iConnMan->IsConnected(connectedDevice.iAddr, connStatus);

                if (connStatus != EBTEngConnecting && connStatus != EBTEngConnected)

                   {

                   TRACE_INFO(_L("Unset EStatusBtuiConnected"))

                   UnsetStatusFlags(iDeviceArray[index]->iStatus,EStatusBtuiConnected );

                   }                

                }

            }

		if(iObserver)

			{

			//Show only phone issued request complete notes

			//Do not show notes for device issued request when BTUI is active

			if ( requestIssuedFromPhone ) 

			    {

        	    iObserver->NotifyChangeDeviceComplete(aErr, connectedDevice);

			    }

        	SendRefreshIfNoError(aErr);

			}		

        }           

    // Process the next command if the connect was

    //initiated by this UI.    

	if(iQueue.Count()>0 && iQueue[0]->iOperation==EOpConnect && 

       iQueue[0]->iAddr == aAddr)        

        {

        delete iQueue[0];

        iQueue.Remove(0);		

        HandleQueue();

        }

    else

        {

        if( iQueue.Count()==0 ) 

            {

            TRACE_INFO((_L("op Q is empty")));

            }

        else

            {

            TRACE_INFO((_L("unexpected op Q contents, count is %d, op is %d"), iDeviceArray.Count(), iQueue[0]->iOperation));

            }

        }

    TRACE_FUNC_EXIT	

    }

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